protected override async Task ConsumerReceived(object sender, BasicDeliverEventArgs eventArgs)
{
string[] result = eventArgs.RoutingKey.Split('.');
var eventName = result.Length > 1 ? result[0] : eventArgs.RoutingKey;
try
{
try
{
var props = eventArgs.BasicProperties;
var replyProps = ConsumerChannel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
var response = await ProcessEventRpc(eventArgs.RoutingKey, eventName, eventArgs.Body).ConfigureAwait(false);
var ms = new MemoryStream();
Serializer.Serialize <IIntegrationEventReply>(ms, response);
var body = ms.ToArray();
ConsumerChannel.BasicPublish(ExchangeDeclareParameters.ExchangeName, (string)response.RoutingKey, replyProps, body);
}
catch (Exception ex)
{
Logger.LogError("CreateConsumerChannel RPC Received: " + ex.Message + " - " + ex.StackTrace);
}
}
catch (Exception ex)
{
Logger.LogWarning("ConsumerReceived: " + eventName + " - " + ex.Message + " - " + ex.StackTrace);
}
// Even on exception we take the message off the queue.
// in a REAL WORLD app this should be handled with a Dead Letter Exchange (DLX).
// For more information see: https://www.rabbitmq.com/dlx.html
ConsumerChannel.BasicAck(eventArgs.DeliveryTag, multiple: false);
}
private void SubsManager_OnEventReplyRemoved(object sender, string eventName)
{
if (!PersistentConnection.IsConnected)
{
PersistentConnection.TryConnect();
}
using (var channel = PersistentConnection.CreateModel())
{
channel.QueueUnbind(QueueName, ExchangeDeclareParameters.ExchangeName, eventName);
channel.QueueUnbind(_queueNameReply, ExchangeDeclareParameters.ExchangeName, eventName);
}
if (!SubsManager.IsReplyEmpty)
{
return;
}
QueueName = string.Empty;
ConsumerChannel?.Close();
//ToDo
_queueNameReply = string.Empty;
_consumerChannelReply?.Close();
}
protected override void DisposeManagedResources()
{
_consumerChannelReply?.Dispose();
ConsumerChannel?.Dispose();
SubsManager?.Clear();
SubsManager?.ClearReply();
}
/// <summary>
/// Acknowledge the message arrival and processing, so that RabbitMq can remove it from the queue.
/// </summary>
/// <param name="msg">The message instance</param>
public void Ack(RabbitWorkMessage msg)
{
if (ConsumerChannel.IsOpen)
{
ConsumerChannel.BasicAck(msg.DeliveryTag, false);
}
}
public MyConsumer(Fiber fiber)
{
_fiber = fiber;
Called = new Stact.Future <MyCommand>();
CommandChannel = new ConsumerChannel <MyCommand>(_fiber, HandleMyCommand);
}
public void Should_capture_the_transform_channel_types()
{
var channel = new ConsumerChannel<string>(new SynchronousFiber(), x => { });
var transform = new TranformChannel<int, string>(new SynchronousFiber(), channel, x => x.ToString());
new ChannelVisitor().Visit(transform);
}
protected TestInstance()
{
_fiber = new SynchronousFiber();
UpdateValueChannel = new ConsumerChannel <UpdateValue>(_fiber, HandleUpdateValue);
PreviousValues = new List <PreviousValue>();
}
public MyConsumer(Fiber fiber)
{
_fiber = fiber;
Called = new Stact.Future<MyCommand>();
CommandChannel = new ConsumerChannel<MyCommand>(_fiber, HandleMyCommand);
}
public void Should_capture_all_of_the_nodes_involved()
{
var channel = new ConsumerChannel <int>(new SynchronousFiber(), x => { });
var filter = new FilterChannel <int>(new SynchronousFiber(), channel, x => true);
new ChannelVisitor().Visit(filter);
}
protected TestInstance()
{
_fiber = new SynchronousFiber();
UpdateValueChannel = new ConsumerChannel<UpdateValue>(_fiber, HandleUpdateValue);
PreviousValues = new List<PreviousValue>();
}
public void Should_capture_all_of_the_nodes_involved()
{
var channel = new ConsumerChannel<int>(new SynchronousFiber(), x => { });
var filter = new FilterChannel<int>(new SynchronousFiber(), channel, x => true);
new ChannelVisitor().Visit(filter);
}
public void Should_capture_the_transform_channel_types()
{
var channel = new ConsumerChannel <string>(new SynchronousFiber(), x => { });
var transform = new ConvertChannel <int, string>(channel, x => x.ToString());
new ChannelVisitor().Visit(transform);
}
protected override async Task ConsumerReceived(object sender, BasicDeliverEventArgs eventArgs)
{
string[] result = eventArgs.RoutingKey.Split('.');
var eventName = result.Length > 1 ? result[0] : eventArgs.RoutingKey;
try
{
//if (!eventArgs.BasicProperties.CorrelationId.Equals(_correlationId)) return;
if (!_callbackMapper.TryRemove(eventArgs.BasicProperties.CorrelationId, out TaskCompletionSource <dynamic> tcs))
{
return;
}
await ProcessEventReply(eventArgs.RoutingKey, eventName, eventArgs.Body, tcs).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.LogWarning("ConsumerReceivedReply: " + eventName + " - " + ex.Message + " - " + ex.StackTrace);
}
// Even on exception we take the message off the queue.
// in a REAL WORLD app this should be handled with a Dead Letter Exchange (DLX).
// For more information see: https://www.rabbitmq.com/dlx.html
ConsumerChannel.BasicAck(eventArgs.DeliveryTag, multiple: false);
}
public void Should_be_fast()
{
Fiber fiber = new ThreadPoolFiber();
const int limit = 5000000;
var complete = new Future<int>();
Channel<MsgStruct> channel = new ConsumerChannel<MsgStruct>(fiber, message =>
{
if (message.Count == limit)
complete.Complete(limit);
});
using (var timer = new FunctionTimer("Throughput", x =>
{
Trace.WriteLine("Time to execute: " + (int) x.ElapsedMilliseconds + "ms");
Trace.WriteLine("Per second throughput: " + (int) (limit/(x.ElapsedMilliseconds/1000)));
}))
{
for (int i = 1; i <= limit; i++)
{
channel.Send(new MsgStruct
{
Count = i,
Other = i*8,
});
}
timer.Mark();
complete.WaitUntilCompleted(30.Seconds()).ShouldBeTrue();
}
}
bool RunTest <T>(int channelCount, int seedCount, Future <int> complete, Func <T> valueProvider)
{
var channels = new Channel <T> [channelCount];
var latch = new CountdownLatch(channelCount * seedCount, complete.Complete);
FiberFactory fiberFactory = () => new PoolFiber();
for (int i = 0; i < channelCount; i++)
{
int channelNumber = i;
channels[i] = new ConsumerChannel <T>(fiberFactory(), x =>
{
if (channelNumber < channels.Length - 1)
{
channels[channelNumber + 1].Send(x);
}
latch.CountDown();
});
}
for (int i = 0; i < seedCount; i++)
{
channels[i].Send(valueProvider());
for (int j = 0; j < i; j++)
{
latch.CountDown();
}
}
return(complete.WaitUntilCompleted(24.Seconds()));
}
/// <summary>
/// Publishes a message to the queue using the QueueName as the routingKey.
/// </summary>
/// <typeparam name="T">The type of the message object.</typeparam>
/// <param name="msg">The message.</param>
/// <param name="exchange">[Optional] The exchange name.</param>
/// <param name="delayMilliseconds">[Optional] The delay milliseconds before the message is available in the queue.</param>
private void PublishMessage <T> (T msg, string exchange, string queueName, int delayMilliseconds)
{
// set persistent property
IBasicProperties basicProperties = null;
if (_publishPersistent)
{
if (basicProperties == null)
{
basicProperties = ConsumerChannel.CreateBasicProperties();
}
basicProperties.Persistent = _publishPersistent;
}
if (_retryDelayMilliseconds > 0)
{
if (basicProperties == null)
{
basicProperties = ConsumerChannel.CreateBasicProperties();
}
basicProperties.AddHeader("x-delay", _retryDelayMilliseconds);
}
// publish message
PublishChannel.BasicPublish(exchange: exchange ?? "",
routingKey: queueName,
basicProperties: basicProperties,
body: GetMessageContent(msg));
}
public Auction(Guid id)
{
Id = id;
Fiber = new PoolFiber();
BidChannel = new ConsumerChannel<Bid>(Fiber, ReceiveBid);
}
public Pinger()
{
_queue = new ThreadPoolActionQueue();
Ponged = new Future<Pong>();
PongChannel = new ConsumerChannel<Pong>(_queue, HandlePong);
}
public Ponger()
{
_fiber = new PoolFiber();
Pinged = new Future <Ping>();
PongChannel = new ConsumerChannel <Ping>(_fiber, HandlePing);
}
public SomeActorInstance()
{
_fiber = new PoolFiber();
_future = new Future<MyMessage>();
MessageChannel = new ConsumerChannel<MyMessage>(_fiber, Consume);
LambdaMessageChannel = new ConsumerChannel<MyMessage>(_fiber, message => _future.Complete(message));
}
public Auction(Guid id)
{
Id = id;
Fiber = new ThreadPoolFiber();
BidChannel = new ConsumerChannel <Bid>(Fiber, ReceiveBid);
}
public Ponger()
{
_fiber = new PoolFiber();
Pinged = new Future<Ping>();
PongChannel = new ConsumerChannel<Ping>(_fiber, HandlePing);
}
public void Should_capture_the_interval_channel()
{
var channel = new ConsumerChannel<ICollection<int>>(new SynchronousFiber(), x => { });
var scheduler = new TimerFiberScheduler(new SynchronousFiber());
var interval = new IntervalChannel<int>(new SynchronousFiber(), scheduler, 5.Minutes(), channel);
new ChannelVisitor().Visit(interval);
}
public void Should_capture_the_interval_channel()
{
var channel = new ConsumerChannel <ICollection <int> >(new SynchronousFiber(), x => { });
var scheduler = new TimerScheduler(new SynchronousFiber());
var interval = new IntervalChannel <int>(new SynchronousFiber(), scheduler, 5.Minutes(), channel);
new ChannelVisitor().Visit(interval);
}
public SomeActorInstance()
{
_fiber = new ThreadPoolFiber();
_future = new Future <MyMessage>();
MessageChannel = new ConsumerChannel <MyMessage>(_fiber, Consume);
LambdaMessageChannel = new ConsumerChannel <MyMessage>(_fiber, message => _future.Complete(message));
}
public Auction(Fiber fiber, Inbox inbox, Guid id)
{
Id = id;
_inbox = inbox;
_fiber = fiber;
AskChannel = new SelectiveConsumerChannel <Request <Ask> >(_fiber, HandleAsk);
EndChannel = new ConsumerChannel <End>(_fiber, x => { _ended = true; });
}
public Auction(Fiber fiber, Inbox inbox, Guid id)
{
Id = id;
_inbox = inbox;
_fiber = fiber;
AskChannel = new SelectiveConsumerChannel<Request<Ask>>(_fiber, HandleAsk);
EndChannel = new ConsumerChannel<End>(_fiber, x => { _ended = true; });
}
public Log4NetLogInstance(Fiber fiber, string source)
{
_fiber = fiber;
_log = LogManager.GetLogger(source);
DebugChannel = new ConsumerChannel <DebugLogMessage>(_fiber, Debug);
ErrorChannel = new ConsumerChannel <ErrorLogMessage>(_fiber, Error);
FatalChannel = new ConsumerChannel <FatalLogMessage>(_fiber, Fatal);
InfoChannel = new ConsumerChannel <InfoLogMessage>(_fiber, Info);
WarnChannel = new ConsumerChannel <WarnLogMessage>(_fiber, Warn);
}
public void Dispose()
{
ConsumerChannel?.Dispose();
ConsumerChannel = null;
if (_timer == null)
{
return;
}
_timer.Dispose();
_timer = null;
}
public void Should_send_to_a_adapter_consumer_chain()
{
Future <TestMessage> future = new Future <TestMessage>();
var consumer = new ConsumerChannel <TestMessage>(_fiber, future.Complete);
var adapter = new ChannelAdapter <TestMessage>(consumer);
adapter.Send(new TestMessage());
future.IsCompleted.ShouldBeTrue();
}
protected override Channel <T> Visitor <T>(ConsumerChannel <T> channel)
{
_current = GetVertex(channel.GetHashCode(), () => "Consumer", typeof(ConsumerChannel <T>), typeof(T));
if (_stack.Count > 0)
{
_edges.Add(new Edge(_stack.Peek(), _current, _current.TargetType.Name));
}
return(WithVertex(() => base.Visitor(channel)));
}
private void StartBasicConsume()
{
var consumer = new AsyncEventingBasicConsumer(ConsumerChannel);
consumer.Received += Consumer_Received;
ConsumerChannel.BasicQos(0, 100, false);
ConsumerChannel.BasicConsume(
queue: QueueDeclare.QueueName,
autoAck: false,
consumer: consumer);
}
public void Run()
{
Stopwatch timer = Stopwatch.StartNew();
FiberFactory fiberFactory = () => new ThreadPoolFiber();
const int channelCount = 10000;
const int seedCount = 500;
var channels = new Channel <string> [channelCount];
var complete = new Future <int>();
var latch = new CountdownLatch(channelCount * seedCount, complete.Complete);
for (int i = 0; i < channelCount; i++)
{
int channelNumber = i;
channels[i] = new ConsumerChannel <string>(fiberFactory(), x =>
{
if (channelNumber < channels.Length - 1)
{
channels[channelNumber + 1].Send(x);
}
latch.CountDown();
});
}
for (int i = 0; i < seedCount; i++)
{
channels[i].Send("Hi");
for (int j = 0; j < i; j++)
{
latch.CountDown();
}
}
bool completed = complete.WaitUntilCompleted(24.Seconds());
timer.Stop();
if (!completed)
{
Console.WriteLine("Process did not complete");
return;
}
Console.WriteLine("Processed {0} messages in with {1} channels in {2}ms", seedCount, channelCount, timer.ElapsedMilliseconds);
Console.WriteLine("That's {0} messages per second!", ((long)seedCount * channelCount * 1000) / timer.ElapsedMilliseconds);
}
/// <summary>
/// Negative acknowledge the message, the message will be returned to the queue or send to dead letter exchange.
/// </summary>
/// <param name="msg">The message instance</param>
/// <param name="requeue">False will send to dead letter exchange, true will send back to the queue.</param>
private void Nack(RabbitWorkMessage msg, bool requeue = false)
{
if (ConsumerChannel.IsOpen)
{
// check max retry limit
if (!requeue && !CheckRetryLimit(_maxRetry - 1, msg))
{
return;
}
ConsumerChannel.BasicNack(msg.DeliveryTag, false, requeue);
}
}
/// <summary>
/// Closes this instance channel to rabbitmq.
/// </summary>
public void Close()
{
if (ConsumerChannel.IsOpen)
{
// set auto close to true, so that it will close if no other channel is active
if (Connection.IsOpen)
{
Connection.AutoClose = true;
}
ConsumerChannel.Close();
}
}
public QueryContent(int id, Consumer <MyContent> callback)
{
Id = id;
var queue = new ThreadPoolFiber();
Channel <MyContent> channel = new ConsumerChannel <MyContent>(new SynchronousFiber(), callback);
if (SynchronizationContext.Current != null)
{
channel = new SynchronizedChannel <MyContent>(queue, channel, SynchronizationContext.Current);
}
ResponseChannel = channel;
}
public QueryContent(int id, Consumer<MyContent> callback)
{
Id = id;
var queue = new ThreadPoolFiber();
Channel<MyContent> channel = new ConsumerChannel<MyContent>(new SynchronousFiber(), callback);
if (SynchronizationContext.Current != null)
{
channel = new SynchronizedChannel<MyContent>(queue, channel, SynchronizationContext.Current);
}
ResponseChannel = channel;
}
public void Run()
{
Stopwatch timer = Stopwatch.StartNew();
FiberFactory fiberFactory = () => new ThreadPoolFiber();
const int channelCount = 10000;
const int seedCount = 500;
var channels = new Channel<string>[channelCount];
var complete = new Future<int>();
var latch = new CountdownLatch(channelCount*seedCount, complete.Complete);
for (int i = 0; i < channelCount; i++)
{
int channelNumber = i;
channels[i] = new ConsumerChannel<string>(fiberFactory(), x =>
{
if (channelNumber < channels.Length - 1)
channels[channelNumber + 1].Send(x);
latch.CountDown();
});
}
for (int i = 0; i < seedCount; i++)
{
channels[i].Send("Hi");
for (int j = 0; j < i; j++)
latch.CountDown();
}
bool completed = complete.WaitUntilCompleted(24.Seconds());
timer.Stop();
if (!completed)
{
Console.WriteLine("Process did not complete");
return;
}
Console.WriteLine("Processed {0} messages in with {1} channels in {2}ms", seedCount, channelCount, timer.ElapsedMilliseconds);
Console.WriteLine("That's {0} messages per second!", ( (long)seedCount * channelCount * 1000) / timer.ElapsedMilliseconds);
}
public void Should_remove_a_consumer_from_an_adapter_chain()
{
var adapter = new ChannelAdapter <TestMessage>(new ShuntChannel <TestMessage>());
var future = new Future <TestMessage>();
var consumer = new ConsumerChannel <TestMessage>(_fiber, future.Complete);
using (ChannelConnection scope = adapter.Connect(x => x.AddChannel(consumer))) {}
new TraceChannelVisitor().Visit(adapter);
adapter.Send(new TestMessage());
future.IsCompleted.ShouldBeFalse();
}
public void Should_remove_my_consumer()
{
var input = new ChannelAdapter();
var futureA = new Future <TestMessage>();
var consumerA = new ConsumerChannel <TestMessage>(new SynchronousFiber(), futureA.Complete);
using (ChannelConnection connection = input.Connect(x => x.AddChannel(consumerA)))
{
}
new TraceChannelVisitor().Visit(input);
input.Send(new TestMessage());
futureA.IsCompleted.ShouldBeFalse();
}
public void Should_work()
{
Stopwatch timer = Stopwatch.StartNew();
FiberFactory fiberFactory = () => new ThreadPoolFiber();
const int channelCount = 10000;
const int seedCount = 500;
var channels = new Channel <string> [channelCount];
var completed = new Future <int>();
var latch = new CountdownLatch(channelCount * seedCount, completed.Complete);
for (int i = 0; i < channelCount; i++)
{
int channelNumber = i;
channels[i] = new ConsumerChannel <string>(fiberFactory(), x =>
{
if (channelNumber < channels.Length - 1)
{
channels[channelNumber + 1].Send(x);
}
latch.CountDown();
});
}
for (int i = 0; i < seedCount; i++)
{
channels[i].Send("Hi");
for (int j = 0; j < i; j++)
{
latch.CountDown();
}
}
completed.WaitUntilCompleted(24.Seconds()).ShouldBeTrue();
timer.Stop();
Trace.WriteLine("Elapsed Time: " + timer.ElapsedMilliseconds + "ms");
}
public void Should_result_in_the_proper_message_data_arriving()
{
var message = new TestMessage {Id = CombGuid.Generate(), Name = "Chris"};
var future = new Stact.Future<TestMessage>();
var consumerChannel = new ConsumerChannel<TestMessage>(new SynchronousFiber(), future.Complete);
var deserializeChannel = new DeserializeChannel<TestMessage>(new SynchronousFiber(), new FastTextSerializer(),
consumerChannel);
var serializeChannel = new SerializeChannel<TestMessage>(new SynchronousFiber(), new FastTextSerializer(),
deserializeChannel);
serializeChannel.Send(message);
future.IsCompleted.ShouldBeTrue();
future.Value.ShouldNotBeTheSameAs(message);
future.Value.ShouldEqual(message);
}
public void IndexAsync()
{
AsyncManager.OutstandingOperations.Increment(2);
Channel<QueryContent> channel = new ConsumerChannel<QueryContent>(new ThreadPoolFiber(), QueryService);
channel.Send(new QueryContent(37, message =>
{
AsyncManager.Parameters["first"] = message;
AsyncManager.OutstandingOperations.Decrement();
}));
channel.Send(new QueryContent(27, message =>
{
AsyncManager.Parameters["second"] = message;
AsyncManager.OutstandingOperations.Decrement();
}));
}
public void IndexAsync()
{
AsyncManager.OutstandingOperations.Increment(2);
Channel <QueryContent> channel = new ConsumerChannel <QueryContent>(new ThreadPoolFiber(), QueryService);
channel.Send(new QueryContent(37, message =>
{
AsyncManager.Parameters["first"] = message;
AsyncManager.OutstandingOperations.Decrement();
}));
channel.Send(new QueryContent(27, message =>
{
AsyncManager.Parameters["second"] = message;
AsyncManager.OutstandingOperations.Decrement();
}));
}
public void Should_add_a_consumer_to_an_empty_adapter_chain()
{
var adapter = new ChannelAdapter<TestMessage>(new ShuntChannel<TestMessage>());
var future = new Future<TestMessage>();
var consumer = new ConsumerChannel<TestMessage>(_fiber, future.Complete);
using (ChannelConnection scope = adapter.Connect(x =>
{
x.AddChannel(consumer);
}))
{
new TraceChannelVisitor().Visit(adapter);
adapter.Send(new TestMessage());
}
future.IsCompleted.ShouldBeTrue();
}
public void Should_add_a_consumer_to_an_empty_adapter_chain()
{
var adapter = new ChannelAdapter <TestMessage>(new ShuntChannel <TestMessage>());
var future = new Future <TestMessage>();
var consumer = new ConsumerChannel <TestMessage>(_fiber, future.Complete);
using (var scope = adapter.Connect(x =>
{
x.AddChannel(consumer);
}))
{
new TraceChannelVisitor().Visit(adapter);
adapter.Send(new TestMessage());
}
future.IsCompleted.ShouldBeTrue();
}
public void Should_add_a_consumer_that_is_assignable_to_the_type()
{
var firstFuture = new Future<TestMessage>();
var secondFuture = new Future<ITestMessage>();
var first = new ConsumerChannel<TestMessage>(_fiber, firstFuture.Complete);
var subs = new BroadcastChannel<TestMessage>(new[] {first});
var adapter = new ChannelAdapter<TestMessage>(subs);
var second = new ConsumerChannel<ITestMessage>(_fiber, secondFuture.Complete);
using (var scope = adapter.Connect(x => x.AddChannel(second)))
{
new TraceChannelVisitor().Visit(adapter);
adapter.Send(new TestMessage());
}
firstFuture.IsCompleted.ShouldBeTrue();
secondFuture.IsCompleted.ShouldBeTrue();
}
public void Should_deliver_the_messages_at_once()
{
var queue = new SynchronousFiber();
var scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future<ICollection<MyMessage>>();
var consumer = new ConsumerChannel<ICollection<MyMessage>>(queue, called.Complete);
var channel = new IntervalChannel<MyMessage>(queue, scheduler, 2.Seconds(), consumer);
for (int i = 0; i < 5; i++)
{
channel.Send(new MyMessage());
}
called.WaitUntilCompleted(4.Seconds()).ShouldBeTrue();
channel.Dispose();
called.Value.ShouldNotBeNull();
called.Value.Count.ShouldEqual(5);
}
public void Should_register_my_consumer()
{
var input = new ChannelAdapter();
var futureA = new Future<TestMessage>();
var consumerA = new ConsumerChannel<TestMessage>(new SynchronousFiber(), futureA.Complete);
var futureB = new Future<TestMessage>();
var consumerB = new ConsumerChannel<TestMessage>(new SynchronousFiber(), futureB.Complete);
using (input.Connect(x =>
{
x.AddChannel(consumerA);
x.AddChannel(consumerB);
}))
{
new TraceChannelVisitor().Visit(input);
input.Send(new TestMessage());
}
futureA.IsCompleted.ShouldBeTrue();
futureB.IsCompleted.ShouldBeTrue();
}
public void Should_remove_my_consumer()
{
var input = new ChannelAdapter();
var futureA = new Future<TestMessage>();
var consumerA = new ConsumerChannel<TestMessage>(new SynchronousFiber(), futureA.Complete);
using (ChannelConnection connection = input.Connect(x => x.AddChannel(consumerA)))
{
}
new TraceChannelVisitor().Visit(input);
input.Send(new TestMessage());
futureA.IsCompleted.ShouldBeFalse();
}
public QueryActor(Fiber fiber)
{
_fiber = fiber;
GetCityChannel = new ConsumerChannel<QueryInputModel>(_fiber, ProcessRequest);
}
public void Should_not_allow_more_than_the_specified_number_of_consumers()
{
int count = 0;
var exceeded = new Future<int>();
var complete = new Future<bool>();
var locker = new object();
int limit = 20;
var provider = new DelegateChannelProvider<TestMessage>(m =>
{
var consumer = new ConsumerChannel<TestMessage>(new SynchronousFiber(), message =>
{
int value = Interlocked.Increment(ref count);
Trace.WriteLine("Value: " + value);
if (value > limit)
exceeded.Complete(value);
message.Complete();
lock (locker)
{
while (complete.IsCompleted == false)
{
Monitor.Wait(locker);
}
}
Interlocked.Decrement(ref count);
});
return consumer;
});
Channel<TestMessage> channel = new ThreadPoolChannel<TestMessage>(provider, limit);
for (int i = 0; i < limit; i++)
{
channel.Send(new TestMessage(() => { }));
}
lock (locker)
{
while (count < limit)
{
Monitor.Wait(locker, 100);
}
}
Trace.WriteLine("Sending extra message to try and break it");
ThreadPool.QueueUserWorkItem(x =>
channel.Send(new TestMessage(() =>
{
lock (locker)
{
complete.Complete(true);
Monitor.PulseAll(locker);
}
})));
lock (locker)
{
Trace.WriteLine("Waiting for message to get executed");
bool ready = Monitor.Wait(locker, 5.Seconds());
// it should not, since the queue is full;
ready.ShouldBeFalse();
}
Trace.WriteLine("Marking complete");
complete.Complete(true);
exceeded.IsCompleted.ShouldBeFalse();
}
public SomeActorInstance()
{
_queue = new ThreadPoolActionQueue();
_future = new Future<MyMessage>();
MessageChannel = new ConsumerChannel<MyMessage>(_queue, Consume);
LambdaMessageChannel = new ConsumerChannel<MyMessage>(_queue, message => _future.Complete(message));
}
public TestConsumer()
{
InputChannel = new ConsumerChannel<TestMessage>(new SynchronousFiber(), x => Future.Complete(x));
}
public EchoActor(Fiber fiber)
{
_fiber = fiber;
EchoChannel = new ConsumerChannel<EchoInputModel>(_fiber, ProcessRequest);
}
public MyConsumer()
{
Input = new ConsumerChannel<SomeEvent>(new SynchronousFiber(), m => { });
}
public TestActor()
{
RunTest = new ConsumerChannel<TestInput>(new SynchronousFiber(), x => { });
}
public void Should_manage_interleaved_changes_the_the_chain()
{
var firstFuture = new Future<TestMessage>();
var secondFuture = new Future<TestMessage>();
var adapter = new ChannelAdapter<TestMessage>(new ShuntChannel<TestMessage>());
var first = new ConsumerChannel<TestMessage>(_fiber, firstFuture.Complete);
var firstScope = adapter.Connect(x => x.AddChannel(first));
var second = new ConsumerChannel<TestMessage>(_fiber, secondFuture.Complete);
var secondScope = adapter.Connect(x => x.AddChannel(second));
firstScope.Dispose();
new TraceChannelVisitor().Visit(adapter);
adapter.Send(new TestMessage());
firstFuture.IsCompleted.ShouldBeFalse();
secondFuture.IsCompleted.ShouldBeTrue();
}
public void Should_remove_a_consumer_from_an_adapter_chain()
{
var adapter = new ChannelAdapter<TestMessage>(new ShuntChannel<TestMessage>());
var future = new Future<TestMessage>();
var consumer = new ConsumerChannel<TestMessage>(_fiber, future.Complete);
using (var scope = adapter.Connect(x => x.AddChannel(consumer)))
{
}
new TraceChannelVisitor().Visit(adapter);
adapter.Send(new TestMessage());
future.IsCompleted.ShouldBeFalse();
}
public void Should_send_to_a_adapter_consumer_chain()
{
Future<TestMessage> future = new Future<TestMessage>();
var consumer = new ConsumerChannel<TestMessage>(_fiber, future.Complete);
var adapter = new ChannelAdapter<TestMessage>(consumer);
adapter.Send(new TestMessage());
future.IsCompleted.ShouldBeTrue();
}
