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(); }