public AsyncQueue(IQueueSerializer queueSerializer, string connectionString, string queueName, ILogger <AsyncQueue <T> > logger)
{
if (queueSerializer == null)
{
throw new ArgumentNullException(nameof(queueSerializer));
}
if (String.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException(nameof(connectionString));
}
if (String.IsNullOrWhiteSpace(queueName))
{
throw new ArgumentNullException(nameof(queueName));
}
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
queueClient.DefaultRequestOptions.RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(120), 3);
_queue = queueClient.GetQueueReference(queueName);
_serializer = queueSerializer;
_queueName = queueName;
_logger = logger;
_logger?.LogTrace("AsyncQueue: created for queue {QUEUENAME}", queueName);
}
public AzureQueueFactory(IQueueFactory queueFactory,
IQueueSerializer queueSerializer,
IConnectionStringProvider connectionStringProvider)
{
_queueFactory = queueFactory;
_queueSerializer = queueSerializer;
_connectionStringProvider = connectionStringProvider;
}
public QueueFactory(IQueueSerializer queueSerializer,
ILoggerFactory loggerFactory,
IConnectionStringProvider connectionStringProvider,
IAzureSettings azureSettings)
{
_queueSerializer = queueSerializer ?? throw new ArgumentNullException(nameof(queueSerializer));
_loggerFactory = loggerFactory;
_connectionStringProvider = connectionStringProvider;
_azureSettings = azureSettings;
}
public LargeMessageQueueFactory(
IQueueFactory queueFactory,
IBlobRepositoryFactory blobRepositoryFactory,
IQueueSerializer serializer,
ILoggerFactory loggerFactory)
{
_queueFactory = queueFactory;
_blobRepositoryFactory = blobRepositoryFactory;
_serializer = serializer;
_loggerFactory = loggerFactory;
}
public IAsyncQueue <T> CreateAsyncQueue <T>(string queueName, IQueueSerializer queueSerializer) where T : class
{
if (_azureSettings.CreateIfNotExists)
{
throw new InvalidOperationException("Creation of resources can only be done through an asynchronous factory");
}
string connectionString = _connectionStringProvider.Get <IAsyncQueue <T> >(queueName);
return(new AsyncQueue <T>(queueSerializer, connectionString, queueName, _loggerFactory.CreateLogger <AsyncQueue <T> >()));
}
public LargeMessageQueue(
IQueueSerializer serializer,
IAsyncQueue <LargeMessageReference> referenceQueue,
IAsyncBlockBlobRepository blobRepository,
ILogger <LargeMessageQueue <T> > logger,
ILargeMessageQueueErrorHandler errorHandler)
{
_serializer = serializer;
_referenceQueue = referenceQueue;
_blobRepository = blobRepository;
_logger = logger;
_errorHandler = errorHandler;
_logger.LogTrace("LargeMessageQueue<T>: constructing");
}
public RabbitQueueManager(IQueueSerializer serializer, IOptions <RabbitOptions> options, ILoggerFactory logFactory)
{
var factory = new ConnectionFactory
{
DispatchConsumersAsync = options.Value.DispatchConsumersAsync,
HostName = options.Value.Host,
Password = options.Value.Password,
Port = options.Value.Port,
UserName = options.Value.User,
VirtualHost = options.Value.VirtualHost,
};
this.Connection = factory.CreateConnection();
this.Options = options.Value;
this.LogFactory = logFactory;
this.Serializer = serializer;
}
public RabbitQueueTopic(
IConnection connection,
IQueueSerializer serializer,
ILogger <T> logger,
string queue = default,
string route = default)
: base(serializer, logger)
{
this.channel = connection.CreateModel();
this.subject = new Subject <T>();
this.Connection = connection;
this.QueueName = queue;
this.Route = string.IsNullOrWhiteSpace(route) ? string.Empty : route;
this.Bind();
}
public QueueLoggerFactory(
IRuntimeEnvironment runtimeEnvironment,
IApplicationResourceSettingNameProvider nameProvider,
IConfiguration configuration,
IQueueSerializer queueSerializer,
IQueueLoggerExtension queueLoggerExtension,
ICorrelationIdProvider correlationIdProvider,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
_runtimeEnvironment = runtimeEnvironment;
_queueSerializer = queueSerializer;
_queueLoggerExtension = queueLoggerExtension;
_correlationIdProvider = correlationIdProvider;
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
_queueName = configuration[nameProvider.SettingName(ApplicationSupportComponentIdentity, "logger-queue")];
_storageAccountConnectionString = configuration[nameProvider.StorageAccountConnectionString(ApplicationSupportComponentIdentity)];
}
public LocalQueueListener(Queue <string> queue, Func <T, Task> callback, IQueueSerializer serializer)
{
this.queue = queue;
this.serializer = serializer;
this.MessageReceivedCallback = callback;
}
public LocalQueueListener(Queue <string> queue, IQueueSerializer serializer) : this(queue, null, serializer)
{
}
public IAsyncQueue <T> CreateAsyncQueue <T>(string queueName, IQueueSerializer queueSerializer) where T : class
{
return(_queueFactory.CreateAsyncQueue <T>(queueName, queueSerializer));
}
protected QueuePattern(IQueueSerializer serializer, ILogger <T> logger)
{
this.Logger = logger;
this.Serializer = serializer;
}
public LocalQueueWriter(Queue <string> queue, IQueueSerializer serializer)
{
this.queue = queue;
this.serializer = serializer;
}
public async Task <IAsyncQueue <T> > CreateAsyncQueueAsync <T>(string queueName, IQueueSerializer queueSerializer) where T : class
{
string connectionString = await _connectionStringProvider.GetAsync <IAsyncQueue <T> >(queueName);
IAsyncQueue <T> result = new AsyncQueue <T>(queueSerializer, connectionString, queueName, _loggerFactory.CreateLogger <AsyncQueue <T> >());
if (_azureSettings.CreateIfNotExists)
{
await result.GetCloudQueue().CreateIfNotExistsAsync();
}
return(result);
}
public RabbitQueueTopic(IConnection connection, IQueueSerializer serializer, ILogger <T> logger)
: this(connection, serializer, logger, typeof(T).GetQueueName(), typeof(T).GetRouteName())
{
}
