public virtual IQueueConfiguration GetConfiguration(QueueMessageSerializer serializer = QueueMessageSerializer.Newtonsoft)
{
return(new QueueConfiguration()
{
AutomaticallyCreateQueues = true, ConnectionString = "UseDevelopmentStorage=true;", CancellationTimeoutInMs = 30000, MessageSerializer = serializer, DefaultMessageEncoding = Azure.Storage.Queues.QueueMessageEncoding.Base64
});
}
protected override async Task Handle(BookTicketCommand request, CancellationToken cancellationToken)
{
var queue = new QueueRepository(QueueName.RequestedToBook);
var serializer = new QueueMessageSerializer(); // lifecycle na single?
await queue.Add(serializer.Serialize(request));
}
public async Task ProcessBufferAsync_WhenMessagesOnBuffer_ExpectSentToQueue()
{
// Arrange
const SerializerType SerializerType = SerializerType.Json;
var queueWrapper = new MockQueueWrapper();
var batchSettings = new BatchSettings {
MaxQueueMessagesPerSchedule = 10, MaxMessagesPerQueueMessage = 10
};
var serializerSettings = new SerializerSettings {
SerializerType = SerializerType
};
var messageSerializer = new MessageSerializer(serializerSettings);
var queueMessageSerializer = new QueueMessageSerializer(batchSettings, messageSerializer);
var buffer = new Buffer(this.LoggerFactory, queueWrapper, queueMessageSerializer);
// Act
var stopwatch = Stopwatch.StartNew();
buffer.AddMessage(new TestEntity {
Data = "d1"
});
buffer.AddMessage(new TestEntity {
Data = "d2"
});
buffer.AddMessage(new TestEntity {
Data = "d3"
});
await buffer.ProcessBufferAsync(CancellationToken.None).ConfigureAwait(false);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var cloudQueueMessage = queueWrapper.Get();
Assert.That(cloudQueueMessage, Is.Not.Null);
var asString = cloudQueueMessage.AsString;
var batchedVersionedMessage = asString.Deserialize <BatchedVersionedMessage>(SerializerType);
Assert.That(batchedVersionedMessage, Is.Not.Null);
var messages = batchedVersionedMessage.Messages.ToList();
Assert.That(messages.Count, Is.EqualTo(3));
Assert.That(messages.All(r => r.Version == new DtoVersion(typeof(TestEntity), 1, 0, 0)), Is.True);
}
public EventStoreToQueueDistributor(
string queueName,
IQueueFactory queueFactory,
IEventStore eventStore,
IDocumentStore projectionStore,
ISerializer serializer)
{
_markerReader = projectionStore.GetReader<string, EventStoreMarker>();
_markerWriter = projectionStore.GetWriter<string, EventStoreMarker>();
_queueName = queueName;
_eventStore = eventStore;
_queueWriter = queueFactory.CreateWriter(queueName);
_serializer = new QueueMessageSerializer(serializer);
}
/// <summary>
/// Creates this instance.
/// </summary>
/// <param name="queueConfiguration">The queue configuration.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <returns>
/// The <see cref="IQueue" />
/// </returns>
public static IQueue Create(
QueueConfiguration queueConfiguration,
ILoggerFactory loggerFactory = null)
{
var logger = loggerFactory ?? new LoggerFactory();
var queueEndpoint = new QueueEndpoint
{
ConnectionString = queueConfiguration.QueueConnectionString,
QueueName = queueConfiguration.QueueName
};
var serializerSettings = new SerializerSettings
{
SerializerType = queueConfiguration.SerializerType
};
var batchSettings = new BatchSettings
{
MaxQueueMessagesPerSchedule = queueConfiguration.MaxQueueMessagesPerSchedule,
MaxMessagesPerQueueMessage = queueConfiguration.MaxMessagesPerQueueMessage
};
var scheduleSettings = new ScheduleSettings
{
ThrottleTime = queueConfiguration.ThrottleTime
};
var queueWrapper = new QueueWrapper(queueEndpoint);
var messageSerializer = new MessageSerializer(serializerSettings);
var queueMessageSerializer = new QueueMessageSerializer(batchSettings, messageSerializer);
var buffer = new Buffer(logger, queueWrapper, queueMessageSerializer);
var stopwatchFactory = new StopwatchFactory();
var delayCalculator = new DelayCalculator();
var pumpProcessor = new PumpProcessor(
logger,
buffer,
stopwatchFactory,
delayCalculator,
scheduleSettings);
var queuePump = new QueuePump(buffer, pumpProcessor);
return(new Queue(queuePump));
}
/// <summary>
/// Registers QueueService helpers, as well as Newtonsoft or System.Text.Json serializers. External ISerializers will not be registered.
/// </summary>
/// <param name="services">the service collection to add helpers/serializers</param>
/// <param name="lifetime">the specified lifetime for the helpers and serializers</param>
/// <param name="serializer">The serializer type to be user by the helper (Newtonsoft or System.Text.Json)</param>
/// <param name="jsonSerializerOptions">Default serialization options for System.Text.Json serializers</param>
/// <param name="serializerSettings">Default serialization options for Newtonsoft.Json serializers</param>
///
public static void RegisterAzureHelperQueueServices(this IServiceCollection services,
ServiceLifetime lifetime = ServiceLifetime.Scoped,
QueueMessageSerializer serializer = QueueMessageSerializer.Newtonsoft,
JsonSerializerOptions jsonSerializerOptions = null,
JsonSerializerSettings serializerSettings = null)
{
switch (lifetime)
{
case ServiceLifetime.Singleton:
services.AddSingleton <IQueueService, QueueService>();
services.AddSerializer(lifetime, serializer, jsonSerializerOptions, serializerSettings);
break;
case ServiceLifetime.Transient:
services.AddTransient <IQueueService, QueueService>();
services.AddSerializer(lifetime, serializer, jsonSerializerOptions, serializerSettings);
break;
default:
services.AddScoped <IQueueService, QueueService>();
services.AddSerializer(lifetime, serializer, jsonSerializerOptions, serializerSettings);
break;
}
}
private static void AddSerializer(this IServiceCollection services, ServiceLifetime lifetime, QueueMessageSerializer serializer, JsonSerializerOptions jsonSerializerOptions, JsonSerializerSettings serializerSettings)
{
switch (serializer)
{
case QueueMessageSerializer.Newtonsoft:
services.AddNewtonsoftSerializer(lifetime, serializerSettings);
return;
case QueueMessageSerializer.SystemTextJson:
services.AddSystemTextJsonSerializer(lifetime, jsonSerializerOptions);
return;
default:
return;
}
}
