protected virtual AbstractEndpoint CreateEndpoint(IMessageHandler handler, MethodInfo method, List <Attribute> annotations)
{
AbstractEndpoint endpoint = null;
var inputChannelName = MessagingAttributeUtils.ResolveAttribute <string>(annotations, InputChannelProperty);
if (!string.IsNullOrEmpty(inputChannelName))
{
IMessageChannel inputChannel;
try
{
inputChannel = ChannelResolver.ResolveDestination(inputChannelName);
if (inputChannel == null)
{
inputChannel = new DirectChannel(ApplicationContext, inputChannelName);
ApplicationContext.Register(inputChannelName, inputChannel);
}
}
catch (DestinationResolutionException)
{
inputChannel = new DirectChannel(ApplicationContext, inputChannelName);
ApplicationContext.Register(inputChannelName, inputChannel);
}
endpoint = DoCreateEndpoint(handler, inputChannel, annotations);
}
return(endpoint);
}
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 NoFailoverNoLoadBalancing()
{
var channel = new DirectChannel(provider.GetService <IApplicationContext>(), null, "noLoadBalancerNoFailover", null);
channel.Failover = false;
handlerA.Setup((h) => h.HandleMessage(message)).Throws(new MessageRejectedException(message, null));
var dispatcher = channel.Dispatcher;
dispatcher.AddHandler(handlerA.Object);
dispatcher.AddHandler(handlerB.Object);
try
{
channel.Send(message);
}
catch (Exception)
{
}
try
{
channel.Send(message);
}
catch (Exception)
{
}
handlerA.Verify((h) => h.HandleMessage(message), Times.Exactly(2));
handlerB.Verify((h) => h.HandleMessage(message), Times.Exactly(0));
}
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 TestConsumerBindingWhenMultiplexingIsEnabled()
{
var searchDirectories = GetSearchDirectories("MockBinder");
var provider = CreateStreamsContainer(
searchDirectories,
"spring.cloud.stream.bindings.input.destination=foo,bar",
"spring.cloud.stream.bindings.input.consumer.multiplex=true")
.BuildServiceProvider();
var factory = provider.GetService <IBinderFactory>();
var binder = factory.GetBinder("mock");
IMessageChannel inputChannel = new DirectChannel(provider);
var mockBinder = Mock.Get <IBinder>(binder);
var service = provider.GetService <BindingService>();
var bindings = service.BindConsumer(inputChannel, "input");
Assert.Single(bindings);
var binding = bindings.First();
var mockBinding = Mock.Get(binding);
service.UnbindConsumers("input");
mockBinder.Verify(b => b.BindConsumer("foo,bar", null, inputChannel, It.IsAny <ConsumerOptions>()));
mockBinding.Verify(b => b.Unbind());
}
public void TestExplicitGroup()
{
var searchDirectories = GetSearchDirectories("MockBinder");
var provider = CreateStreamsContainer(
searchDirectories,
"spring.cloud.stream.bindings.input.destination=foo",
"spring.cloud.stream.bindings.input.group=fooGroup")
.BuildServiceProvider();
var factory = provider.GetService <IBinderFactory>();
var binder = factory.GetBinder("mock");
IMessageChannel inputChannel = new DirectChannel(provider.GetService <IApplicationContext>());
var mockBinder = Mock.Get <IBinder>(binder);
var service = provider.GetService <BindingService>();
var bindings = service.BindConsumer(inputChannel, "input");
Assert.Single(bindings);
var binding = bindings.First();
var mockBinding = Mock.Get(binding);
service.UnbindConsumers("input");
mockBinder.Verify(b => b.BindConsumer("foo", "fooGroup", inputChannel, It.IsAny <ConsumerOptions>()));
mockBinding.Verify(b => b.Unbind());
}
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 async Task ValidateSuccessfulErrorFlowDoesNotThrowErrors()
{
var provider = services.BuildServiceProvider();
var outChannel = new DirectChannel(provider);
var handler = new ExceptionHandler();
outChannel.Subscribe(handler);
var errorChannel = new PublishSubscribeChannel(provider);
var errorService = new SuccessfulErrorService();
var errorHandler = new ServiceActivatingHandler(provider, errorService);
errorChannel.Subscribe(errorHandler);
var mps = new TestMessageProducerSupportEndpoint(provider);
mps.OutputChannel = outChannel;
mps.ErrorChannel = errorChannel;
await mps.Start();
var message = new GenericMessage("hello");
mps.SendMessage(message);
Assert.IsType <ErrorMessage>(errorService.LastMessage);
Assert.IsType <MessageDeliveryException>(errorService.LastMessage.Payload);
var exception = (MessageDeliveryException)errorService.LastMessage.Payload;
Assert.Equal(message, exception.FailedMessage);
}
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 channel = new DirectChannel(provider.GetService <IApplicationContext>());
var handler = new CounterHandler();
channel.Subscribe(handler);
var message = Message.Create("test");
Assert.True(channel.Send(message));
for (var i = 0; i < 10000000; i++)
{
channel.Send(message);
}
Assert.Equal(10000001, handler.Count);
}
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 TestMultipleConsumerBindings()
{
var searchDirectories = GetSearchDirectories("MockBinder");
var provider = CreateStreamsContainer(
searchDirectories,
"spring.cloud.stream.bindings.input.destination=foo,bar")
.BuildServiceProvider();
var factory = provider.GetService <IBinderFactory>();
var binder = factory.GetBinder("mock");
IMessageChannel inputChannel = new DirectChannel(provider);
var mockBinder = Mock.Get <IBinder>(binder);
var service = provider.GetService <BindingService>();
var bindings = service.BindConsumer(inputChannel, "input");
var bindingsAsList = bindings.ToList();
Assert.Equal(2, bindingsAsList.Count);
var binding1 = bindingsAsList[0];
var binding2 = bindingsAsList[1];
var mockBinding1 = Mock.Get(binding1);
var mockBinding2 = Mock.Get(binding2);
service.UnbindConsumers("input");
mockBinder.Verify(b => b.BindConsumer("foo", null, inputChannel, It.IsAny <ConsumerOptions>()));
mockBinder.Verify(b => b.BindConsumer("bar", null, inputChannel, It.IsAny <ConsumerOptions>()));
mockBinding1.Verify(b => b.Unbind());
mockBinding2.Verify(b => b.Unbind());
}
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 channel = new DirectChannel(provider.GetService <IApplicationContext>());
var count1 = new CounterHandler();
var count2 = new CounterHandler();
channel.Subscribe(count1);
channel.Subscribe(count2);
var message = Message.Create("test");
for (var i = 0; i < 10000000; i++)
{
channel.Send(message);
}
Assert.Equal(5000000, count1.Count);
Assert.Equal(5000000, count2.Count);
}
public static IServiceCollection AddDirectChannel(this IServiceCollection services, string channelName, Action <IServiceProvider, DirectChannel> configure)
{
if (string.IsNullOrEmpty(channelName))
{
throw new ArgumentNullException(nameof(channelName));
}
services.RegisterService(channelName, typeof(IMessageChannel));
services.AddSingleton <IMessageChannel>((p) =>
{
var context = p.GetService <IApplicationContext>();
var chan = new DirectChannel(context)
{
ServiceName = channelName
};
configure?.Invoke(p, chan);
return(chan);
});
services.RegisterService(channelName, typeof(ISubscribableChannel));
services.AddSingleton <ISubscribableChannel>((p) =>
{
var context = p.GetService <IApplicationContext>();
return(GetRequiredChannel <ISubscribableChannel>(context, channelName));
});
return(services);
}
public void FailoverNoLoadBalancingConcurrent()
{
var channel = new DirectChannel(provider.GetService <IApplicationContext>(), null, "noLoadBalancerFailover", null);
channel.Failover = true;
handlerA.Setup((h) => h.HandleMessage(message)).Throws(new MessageRejectedException(message, null));
var dispatcher = channel.Dispatcher;
dispatcher.AddHandler(handlerA.Object);
dispatcher.AddHandler(handlerB.Object);
dispatcher.AddHandler(handlerC.Object);
var start1 = new CountdownEvent(1);
var allDone1 = new CountdownEvent(TOTAL_EXECUTIONS);
var message2 = message;
var failed1 = 0;
void MessageSenderTask()
{
try
{
start1.Wait();
}
catch (Exception)
{
throw;
}
var sent = false;
try
{
sent = channel.Send(message2);
}
catch (Exception e2)
{
exceptionRegistry.Object.Add(e2);
}
if (!sent)
{
failed1 = 1;
}
allDone1.Signal();
}
for (var i = 0; i < TOTAL_EXECUTIONS; i++)
{
Task.Run(MessageSenderTask);
}
start1.Signal();
Assert.True(allDone1.Wait(10000));
Assert.Equal(0, failed1);
handlerA.Verify((h) => h.HandleMessage(message2), Times.Exactly(TOTAL_EXECUTIONS));
handlerB.Verify((h) => h.HandleMessage(message2), Times.Exactly(TOTAL_EXECUTIONS));
handlerC.Verify((h) => h.HandleMessage(message2), Times.Never());
exceptionRegistry.Verify((list) => list.Add(It.IsAny <Exception>()), Times.Never());
}
public void ReceiveWithNonPollableDefaultFails()
{
DirectChannel channel = new DirectChannel();
MessageChannelTemplate template = new MessageChannelTemplate(channel);
template.Receive();
}
public void FailoverNoLoadBalancing()
{
var channel = new DirectChannel(provider, null, "loadBalancerNoFailover", null);
channel.Failover = true;
handlerA.Setup((h) => h.HandleMessage(message)).Throws(new MessageRejectedException(message, null));
var dispatcher = channel.Dispatcher;
dispatcher.AddHandler(handlerA.Object);
dispatcher.AddHandler(handlerB.Object);
try
{
channel.Send(message);
}
catch (Exception)
{ /* ignore */
}
handlerA.Verify((h) => h.HandleMessage(message), Times.Exactly(1));
handlerB.Verify((h) => h.HandleMessage(message), Times.Exactly(1));
try
{
channel.Send(message);
}
catch (Exception)
{ /* ignore */
}
handlerA.Verify((h) => h.HandleMessage(message), Times.Exactly(2));
handlerB.Verify((h) => h.HandleMessage(message), Times.Exactly(2));
}
public void TestTryComplete()
{
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider.GetService <IApplicationContext>());
Assert.False(channel.Writer.TryComplete());
}
public void TestTryComplete()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new DirectChannel(provider);
Assert.False(channel.Writer.TryComplete());
}
public async Task TestSendAsync()
{
var target = new ThreadNameExtractingTestTarget();
var channel = new DirectChannel(provider.GetService <IApplicationContext>());
channel.Subscribe(target);
var message = Message.Create("test");
Assert.True(await channel.SendAsync(message));
}
public void NoFailoverNoLoadBalancingConcurrent()
{
var channel = new DirectChannel(provider, null, "noLoadBalancerNoFailover", null);
channel.Failover = false;
handlerA.Setup((h) => h.HandleMessage(message)).Throws(new MessageRejectedException(message, null));
var dispatcher = channel.Dispatcher;
dispatcher.AddHandler(handlerA.Object);
dispatcher.AddHandler(handlerB.Object);
void MessageSenderTask()
{
try
{
start.Wait();
}
catch (Exception)
{
throw;
}
var sent = false;
try
{
sent = channel.Send(message);
}
catch (Exception e2)
{
exceptionRegistry.Object.Add(e2);
}
if (!sent)
{
failed = 1;
}
allDone.Signal();
}
for (var i = 0; i < TOTAL_EXECUTIONS; i++)
{
Task.Run(MessageSenderTask);
}
start.Signal();
Assert.True(allDone.Wait(10000));
Assert.Equal(1, failed);
handlerA.Verify((h) => h.HandleMessage(message), Times.Exactly(TOTAL_EXECUTIONS));
handlerB.Verify((h) => h.HandleMessage(message), Times.Exactly(0));
exceptionRegistry.Verify((list) => list.Add(It.IsAny <Exception>()), Times.Exactly(TOTAL_EXECUTIONS));
}
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 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 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));
}
internal BindableDirectChannel(
IMessenger messenger,
IClipboardService clipboardService,
IDiscordService discordService,
QuarrelClient quarrelClient,
IDispatcherService dispatcherService,
DirectChannel directChannel) :
base(messenger, clipboardService, discordService, quarrelClient, dispatcherService, directChannel)
{
var user = _quarrelClient.Users.GetUser(DirectChannel.RecipientId);
Guard.IsNotNull(user);
Recipient = new BindableUser(_messenger, _discordService, _quarrelClient, _dispatcherService, user);
}
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 void TestCorrelationIdPassedIfAvailable()
{
object correlationId = "123-ABC";
IMessage message = MessageBuilder.WithPayload("test").SetCorrelationId(correlationId).Build();
DirectChannel inputChannel = new DirectChannel();
QueueChannel outputChannel = new QueueChannel(1);
ServiceActivatingHandler serviceActivator = new ServiceActivatingHandler(new TestBean(), "UpperCase");
serviceActivator.OutputChannel = outputChannel;
EventDrivenConsumer endpoint = new EventDrivenConsumer(inputChannel, serviceActivator);
endpoint.Start();
Assert.IsTrue(inputChannel.Send(message));
IMessage reply = outputChannel.Receive(TimeSpan.Zero);
Assert.That(reply.Headers.CorrelationId, Is.EqualTo(correlationId));
}
public void TestSend()
{
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;
Assert.True(channel.Send(message));
Assert.Equal(currentId, target.TaskId);
Assert.Equal(curThreadId, target.ThreadId);
}
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 TestSendInSeparateThread()
{
var latch = new CountdownEvent(1);
var channel = new DirectChannel(provider.GetService <IApplicationContext>());
var target = new ThreadNameExtractingTestTarget(latch);
channel.Subscribe(target);
var message = Message.Create("test");
var thread = new Thread(() => channel.Send(message));
thread.Name = "test-thread";
thread.Start();
latch.Wait(1000);
Assert.Equal("test-thread", target.ThreadName);
}
private void ConfigureChain()
{
DirectChannel channel = null;
IList<IMessageHandler> handlers = _handlers;
for(int i = 0; i < handlers.Count; i++) {
bool first = (i == 0);
bool last = (i == handlers.Count - 1);
IMessageHandler handler = handlers[i];
if(!first) {
EventDrivenConsumer consumer = new EventDrivenConsumer(channel, handler);
consumer.Start();
}
if(!last) {
if(!(handler is AbstractReplyProducingMessageHandler))
throw new ArgumentException("All handlers except for the last one in the chain must implement " + typeof(AbstractReplyProducingMessageHandler).Name);
channel = new DirectChannel();
channel.ObjectName = "_" + this + ".channel#" + i;
((AbstractReplyProducingMessageHandler)handler).OutputChannel = channel;
}
else if(handler is AbstractReplyProducingMessageHandler) {
IMessageChannel replyChannel = (_outputChannel != null) ? _outputChannel : new ReplyForwardingMessageChannel(this);
((AbstractReplyProducingMessageHandler)handler).OutputChannel = replyChannel;
}
else {
if(_outputChannel == null)
throw new ArgumentException("An output channel was provided, but the final handler in the chain is not an "
+ "instance of [" + typeof(AbstractReplyProducingMessageHandler).Name + "]");
}
}
}
public void TestCorrelationNotCopiedFromRequestMessgeIdIfAlreadySetByHandler()
{
IMessage message = new StringMessage("test");
DirectChannel inputChannel = new DirectChannel();
QueueChannel outputChannel = new QueueChannel(1);
ServiceActivatingHandler serviceActivator = new ServiceActivatingHandler(new TestBean(), "CreateMessage");
serviceActivator.OutputChannel = outputChannel;
EventDrivenConsumer endpoint = new EventDrivenConsumer(inputChannel, serviceActivator);
endpoint.Start();
Assert.IsTrue(inputChannel.Send(message));
IMessage reply = outputChannel.Receive(TimeSpan.Zero);
Assert.That(reply.Headers.CorrelationId, Is.EqualTo("456-XYZ"));
}
public void ReceiveWithNonPollableDefaultFails()
{
DirectChannel channel = new DirectChannel();
MessageChannelTemplate template = new MessageChannelTemplate(channel);
template.Receive();
}
