public RedisDataManager(RedisStreamOptions options, IConnectionMultiplexerFactory connectionMultiplexerFactory, ILogger loggerFactory, string queueName, string serviceId, string clusterId)
: this(
options,
connectionMultiplexerFactory,
loggerFactory,
options.PersistenceLifetime == PersistenceLifetime.ServiceLifetime ? (serviceId + ":" + queueName) : (clusterId + ":" + queueName))
{
}
private RedisDataManager(RedisStreamOptions options, IConnectionMultiplexerFactory connectionMultiplexerFactory, ILogger logger, string queueName)
{
queueName = SanitizeQueueName(queueName);
ValidateQueueName(queueName);
_options = options;
_connectionMultiplexerFactory = connectionMultiplexerFactory;
_logger = logger.ForContext <RedisDataManager>();
QueueName = queueName;
_redisChannel = new RedisChannel(QueueName, RedisChannel.PatternMode.Literal);
}
public RedisQueueAdapter(
RedisStreamOptions options,
IConnectionMultiplexerFactory connectionMultiplexerFactory,
IRedisDataAdapter dataAdapter,
IStreamQueueMapper streamQueueMapper,
ILogger logger,
string serviceId,
string clusterId,
string providerName)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (connectionMultiplexerFactory == null)
{
throw new ArgumentNullException(nameof(connectionMultiplexerFactory));
}
if (dataAdapter == null)
{
throw new ArgumentNullException(nameof(dataAdapter));
}
if (streamQueueMapper == null)
{
throw new ArgumentNullException(nameof(streamQueueMapper));
}
if (string.IsNullOrEmpty(serviceId))
{
throw new ArgumentNullException(nameof(serviceId));
}
if (string.IsNullOrEmpty(clusterId))
{
throw new ArgumentNullException(nameof(clusterId));
}
if (string.IsNullOrEmpty(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
_redisStreamOptions = options;
_connectionMultiplexerFactory = connectionMultiplexerFactory;
ServiceId = serviceId;
ClusterId = clusterId;
Name = providerName;
_streamQueueMapper = streamQueueMapper;
_dataAdapter = dataAdapter;
_logger = logger.ForContext <RedisQueueAdapter>(new Dictionary <string, object>
{
{ "ServiceId", serviceId },
{ "ProviderName", providerName }
});
}
public RedisQueueAdapter(
RedisStreamOptions options,
IConnectionMultiplexerFactory connectionMultiplexerFactory,
IRedisDataAdapter dataAdapter,
IStreamQueueMapper streamQueueMapper,
ILogger logger,
string serviceId,
string providerName)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (connectionMultiplexerFactory == null)
{
throw new ArgumentNullException(nameof(connectionMultiplexerFactory));
}
if (dataAdapter == null)
{
throw new ArgumentNullException(nameof(dataAdapter));
}
if (streamQueueMapper == null)
{
throw new ArgumentNullException(nameof(streamQueueMapper));
}
if (string.IsNullOrEmpty(serviceId))
{
throw new ArgumentNullException(nameof(serviceId));
}
if (string.IsNullOrEmpty(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
_redisStreamOptions = options;
_connectionMultiplexerFactory = connectionMultiplexerFactory;
ServiceId = serviceId;
Name = providerName;
_streamQueueMapper = streamQueueMapper;
_dataAdapter = dataAdapter;
_logger = (logger ?? SilentLogger.Logger).ForContext <RedisQueueAdapter>();
}
private (Mock <IConnectionMultiplexer> MockConnectionMultiplexer, Mock <ISubscriber> MockSubscriber, RedisDataManager RedisDataManager) MockRedisDataManager(Mock <IConnectionMultiplexerFactory> connectionMultiplexerFactory = null, RedisStreamOptions redisStreamOptions = null)
{
var mockConnectionMultiplexer = new Mock <IConnectionMultiplexer> {
DefaultValue = DefaultValue.Mock
};
var mockSubscriber = new Mock <ISubscriber> {
DefaultValue = DefaultValue.Mock
};
mockConnectionMultiplexer
.Setup(x => x.GetSubscriber(It.IsAny <object>()))
.Returns(mockSubscriber.Object);
var rdm = new RedisDataManager(
redisStreamOptions ?? TestConstants.ValidRedisStreamOptions,
connectionMultiplexerFactory?.Object ?? MockConnectionMultiplexerFactory.Returns(mockConnectionMultiplexer.Object),
null,
TestConstants.ValidQueueName,
TestConstants.ValidServiceId);
return(mockConnectionMultiplexer, mockSubscriber, rdm);
}
public RedisDataManager(RedisStreamOptions options, IConnectionMultiplexerFactory connectionMultiplexerFactory, ILogger loggerFactory, string queueName, string serviceId)
: this(options, connectionMultiplexerFactory, loggerFactory, serviceId + ":" + queueName)
{
}
public RedisQueueAdapterFactory(
string name,
RedisStreamOptions options,
IConnectionMultiplexerFactory connectionMultiplexerFactory,
HashRingStreamQueueMapperOptions queueMapperOptions,
SimpleQueueCacheOptions cacheOptions,
IServiceProvider serviceProvider,
IOptions <ClusterOptions> clusterOptions,
IRedisDataAdapter dataAdapter,
ILogger logger,
ISerializationManager serializationManager)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (connectionMultiplexerFactory == null)
{
throw new ArgumentNullException(nameof(connectionMultiplexerFactory));
}
if (queueMapperOptions == null)
{
throw new ArgumentNullException(nameof(queueMapperOptions));
}
if (cacheOptions == null)
{
throw new ArgumentNullException(nameof(cacheOptions));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (clusterOptions == null)
{
throw new ArgumentNullException(nameof(clusterOptions));
}
if (dataAdapter == null)
{
throw new ArgumentNullException(nameof(dataAdapter));
}
if (serializationManager == null)
{
throw new ArgumentNullException(nameof(serializationManager));
}
_providerName = name;
_options = options;
_connectionMultiplexerFactory = connectionMultiplexerFactory;
_clusterOptions = clusterOptions.Value;
_logger = logger.ForContext <RedisQueueAdapterFactory>();
_dataAdapter = dataAdapter;
_streamQueueMapper = new HashRingBasedStreamQueueMapper(queueMapperOptions, _providerName);
var microsoftLoggerFactory = serviceProvider.GetService <Microsoft.Extensions.Logging.ILoggerFactory>();
_adapterCache = new SimpleQueueAdapterCache(cacheOptions, _providerName, microsoftLoggerFactory);
}
