public void Execute(AutoResetEvent block)
{
const int filesToCreate = 100;
var filesProcessed = 0;
// This setup will emit files on another thread
var producesInts = new ObservingProducer <int>();
producesInts.Produces(Observable.Range(1, filesToCreate)).Attach(new FileConsumer <int>());
producesInts.Start();
// This setup will output the contents of loaded files to the console
var fileProducer = new FileProducer <int>();
var logger = new ActionConsumer <int>(i =>
{
filesProcessed++;
Console.WriteLine(filesProcessed);
if (filesProcessed >= filesToCreate)
{
block.Set();
}
});
fileProducer.Attach(logger);
fileProducer.Start();
}
/// <summary>
/// Perform a request/response
/// </summary>
/// <typeparam name="TMessage">The type of the message being sent</typeparam>
/// <typeparam name="TEvent">The type of the event for the response</typeparam>
/// <param name="bus">The bus to send/receive from</param>
/// <param name="message">The message to send</param>
/// <param name="cancellationToken">CancellationToken to use to cancel or timeout.</param>
/// <returns>The event response</returns>
public static Task <TEvent> RequestAsync <TMessage, TEvent>(this IBus bus, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
where TEvent : IEvent
{
if (bus == null)
{
throw new ArgumentNullException(nameof(bus));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var tcs = new TaskCompletionSource <TEvent>();
cancellationToken.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: false);
ActionConsumer <TEvent> actionConsumer = null;
actionConsumer = new ActionConsumer <TEvent>(e =>
{
if (actionConsumer != null)
{
bus.RemoveHandler(actionConsumer);
}
tcs.SetResult(e);
});
bus.AddHandler(actionConsumer);
bus.Send(message);
return(tcs.Task);
}
public void NullDelegateCausesException()
{
Assert.Throws <ArgumentNullException>(() =>
{
var ac = new ActionConsumer <IMessage>(null);
});
}
public void RemovingHandlerBeforeProcessingThrows()
{
var bus = new Bus();
var actionConsumer = new ActionConsumer <Message1>(m => { });
var token = bus.AddHandler(actionConsumer);
Assert.Throws <MessageHandlerRemovedBeforeProcessingMessageException <Message1> >(() => bus.RemoveHandler(actionConsumer, token));
}
public void Execute(AutoResetEvent block)
{
var producer = new ObservingProducer <int>();
var consumer = new ActionConsumer <int>(i => Console.WriteLine(i));
producer.Attach(consumer);
producer.Produces(Observable.Range(1, 10000), onCompleted: () => block.Set());
producer.Start();
}
public void RemoveHandlerTwiceSucceeds()
{
var bus = new Bus();
var actionConsumer1 = new ActionConsumer <Message1>(m => { });
var token1 = bus.AddHandler(actionConsumer1);
bus.Send(new Message1());
bus.RemoveHandler(actionConsumer1, token1);
bus.RemoveHandler(actionConsumer1, token1);
}
public void InterleavedRemoveHandlerRemovesCorrectHandler()
{
string ordinal = null;
var bus = new Bus();
var actionConsumer1 = new ActionConsumer <Message1>(m => ordinal = "1");
var token1 = bus.AddHandler(actionConsumer1);
var actionConsumer2 = new ActionConsumer <Message1>(m => ordinal = "2");
var token2 = bus.AddHandler(actionConsumer2);
bus.RemoveHandler(actionConsumer1, token1);
bus.Send(new Message1());
Assert.AreEqual("2", ordinal);
}
public void Execute(AutoResetEvent block)
{
var producer = new ObservingProducer <int>();
var consumer = new ActionConsumer <int>(i => Console.WriteLine(i));
var serializer = new BinarySerializer();
var outbound = new ProtocolProducer <int>(serializer); // This is a producer of a data stream that consumes T events (serializer)
var inbound = new ProtocolConsumer <int>(serializer); // This is a consumer of a data stream that produces T events (deserializer)
outbound.Attach(inbound); // Typically you'd put an enqueing consumer here to shuttle serialized events off-network
inbound.Attach(consumer);
producer.Attach(outbound);
producer.Produces(Observable.Range(1, 10000), onCompleted: () => block.Set());
producer.Start();
}
private BackgroundThreadProducer(BlockingCollection <T> source, bool @internal = true)
{
_buffer = source;
_internal = @internal;
MaxDegreeOfParallelism = 1;
_uptime = new Stopwatch();
_cancel = new CancellationTokenSource();
_empty = new SemaphoreSlim(1);
var devNull = new ActionConsumer <QueuedMessage <T> >(message => { });
_consumer = devNull;
_backlogConsumer = devNull;
_undeliverableConsumer = devNull;
}
public BackgroundThreadProducer(BlockingCollection <T> source)
{
Buffer = source;
MaxDegreeOfParallelism = 1;
_uptime = new Stopwatch();
_cancel = new CancellationTokenSource();
_empty = new SemaphoreSlim(1);
RetryPolicy = new RetryPolicy();
RateLimitPolicy = new RateLimitPolicy();
var devNull = new ActionConsumer <T>(@event => { });
_consumer = devNull;
_backlogConsumer = devNull;
_undeliverableConsumer = devNull;
}
public async Task SqsBasic_Consumer_WithProtocol_NoMessages()
{
var count = 0;
var hitCode = false;
using (var c = SqsHelper.CreateConnection(this.Logger, SqsSettings.DefaultSection, UnitTestSettingsFile))
{
using (var mq1 = new ActionConsumer <Scan>(x => { Interlocked.Increment(ref count); }, c.CreateRetriever(), new ProtoBufOverAmqp <Scan>(), c.CreateConsumer(), this.Logger))
{
await Task.Delay(15000);
}
using (var mq2 = new ActionConsumer <Scan>(x => { Interlocked.Increment(ref count); }, c.CreateRetriever(), new ProtoBufOverAmqp <Scan>(), c.CreateConsumer(), this.Logger))
{
mq2.Initialize();
await Task.Delay(15000);
}
hitCode = true;
}
Assert.AreEqual(0, count);
Assert.IsTrue(hitCode);
}
/// <summary>
/// Perform a request/response
/// </summary>
/// <typeparam name="TMessage">The type of the message being sent</typeparam>
/// <typeparam name="TSuccessEvent">The type of the event for the response</typeparam>
/// <param name="bus">The bus to send/receive from</param>
/// <param name="message">The message to send</param>
/// <param name="cancellationToken">CancellationToken to use to cancel or timeout.</param>
/// <returns>The event response</returns>
public static Task <TSuccessEvent> RequestAsync <TMessage, TSuccessEvent, TErrorEvent>(this IBus bus, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
where TSuccessEvent : IEvent
where TErrorEvent : IEvent
{
if (bus == null)
{
throw new ArgumentNullException(nameof(bus));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var tcs = new TaskCompletionSource <TSuccessEvent>();
ActionConsumer <TSuccessEvent> successActionConsumer = null;
ActionConsumer <TErrorEvent> errorActionConsumer = null;
object successToken = null;
object errorToken = null;
cancellationToken.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: false);
{
successActionConsumer = new ActionConsumer <TSuccessEvent>(e =>
{
try
{
if (e.CorrelationId != message.CorrelationId)
{
return;
}
if (successActionConsumer != null)
{
bus.RemoveHandler(successActionConsumer, successToken);
}
if (errorActionConsumer != null)
{
bus.RemoveHandler(errorActionConsumer, errorToken);
}
tcs.SetResult(e);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
successToken = bus.AddHandler(successActionConsumer);
}
{
errorActionConsumer = new ActionConsumer <TErrorEvent>(e =>
{
try
{
if (e.CorrelationId != message.CorrelationId)
{
return;
}
if (errorActionConsumer != null)
{
bus.RemoveHandler(errorActionConsumer, errorToken);
}
if (successActionConsumer != null)
{
bus.RemoveHandler(successActionConsumer, successToken);
}
tcs.SetException(new ReceivedErrorEventException <TErrorEvent>(e));
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
errorToken = bus.AddHandler(errorActionConsumer);
}
bus.Send(message);
return(tcs.Task);
}
