public async void ConnectRetriesOnError() { int invokationCount = 0; var wh = new ManualResetEventSlim(); var redisConnection = GetMockRedisConnection(); var tcs = new TaskCompletionSource <object>(); tcs.TrySetCanceled(); redisConnection.Setup(m => m.ConnectAsync(It.IsAny <string>(), It.IsAny <TraceSource>())).Returns <string, TraceSource>((connectionString, trace) => { if (++invokationCount == 2) { wh.Set(); return(Task.FromResult(0)); } else { return(tcs.Task); } }); var redisMessageBus = new RedisMessageBus(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty), redisConnection.Object, false); await redisMessageBus.ConnectWithRetry(); Assert.True(wh.Wait(TimeSpan.FromSeconds(5))); Assert.Equal(RedisMessageBus.State.Connected, redisMessageBus.ConnectionState); }
public HybridCacheClient(ConnectionMultiplexer connectionMultiplexer) { _redisCache = new RedisCacheClient(connectionMultiplexer); _localCache.MaxItems = 100; _messageBus = new RedisMessageBus(connectionMultiplexer.GetSubscriber(), "cache"); _messageBus.Subscribe <InvalidateCache>(OnMessage); }
public async void ConnectRetriesOnError() { int invokationCount = 0; var wh = new ManualResetEventSlim(); var redisConnection = GetMockRedisConnection(); var tcs = new TaskCompletionSource <object>(); tcs.TrySetCanceled(); redisConnection.Setup(m => m.ConnectAsync(It.IsAny <string>(), It.IsAny <ILogger>())).Returns <string, ILogger>((connectionString, logger) => { if (++invokationCount == 2) { wh.Set(); return(Task.FromResult(0)); } else { //Return cancelled task to insert error return(tcs.Task); } }); var redisMessageBus = new RedisMessageBus(new Mock <IStringMinifier>().Object, new TestLoggerFactory(), new PerformanceCounterManager(new TestLoggerFactory()), new MessageBusOptionsAccessor(), new RedisOptionsAccessor(), redisConnection.Object, false); await redisMessageBus.ConnectWithRetry(); Assert.True(wh.Wait(TimeSpan.FromSeconds(5))); Assert.Equal(RedisMessageBus.State.Connected, redisMessageBus.ConnectionState); }
public RedisMessageBusTests() { //if (!Settings.Current.UseAzureServiceBus) // return; var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString()); _messageBus = new RedisMessageBus(muxer.GetSubscriber()); }
public async void ConnectRetriesOnError() { int invokationCount = 0; var wh = new ManualResetEventSlim(); var redisConnection = GetMockRedisConnection(); var tcs = new TaskCompletionSource<object>(); tcs.TrySetCanceled(); redisConnection.Setup(m => m.ConnectAsync(It.IsAny<string>(), It.IsAny<TraceSource>())).Returns<string, TraceSource>((connectionString, trace) => { if (++invokationCount == 2) { wh.Set(); return Task.FromResult(0); } else { return tcs.Task; } }); var redisMessageBus = new RedisMessageBus(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty), redisConnection.Object, false); await redisMessageBus.ConnectWithRetry(); Assert.True(wh.Wait(TimeSpan.FromSeconds(5))); Assert.Equal(RedisMessageBus.State.Connected, redisMessageBus.ConnectionState); }
public RedisAsyncState(RedisCacheStore redisCache, RedisMessageBus bus) : base(redisCache) { _bus = bus; // Subscribe to async state events (e.g. "Cancel") sent by other nodes in the web farm _bus.Subscribe(Channel, OnAsyncStateEvent); }
public PerfomanceTwoLayerRealCacheTest() { var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"]; MemoryCacheImpl cacheLayer1 = new MemoryCacheImpl("PerfomanceTwoLayerRealCacheTest"); RedisCacheImpl cacheLayer2 = new RedisCacheImpl("PerfomanceTwoLayerRealCacheTest", connectionString); RedisMessageBus messageBus = new RedisMessageBus(connectionString); _testCache = new TwoLayerCacheImpl(cacheLayer1, cacheLayer2, messageBus); }
public void SetUp() { var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"]; _cacheLayer1 = new MemoryCacheImpl("TwoLayerCacheRealMemoryTest"); _cacheLayer2 = new RedisCacheImpl("TwoLayerCacheRealMemoryTest", connectionString); _messageBus = new RedisMessageBus(connectionString); _testCache = new TwoLayerCacheImpl(_cacheLayer1, _cacheLayer2, _messageBus); }
public override async Task CanHaveMultipleQueueInstancesWithLockingAsync() { var muxer = SharedConnection.GetMuxer(); using var cache = new RedisCacheClient(new RedisCacheClientOptions { ConnectionMultiplexer = muxer, LoggerFactory = Log }); using var messageBus = new RedisMessageBus(new RedisMessageBusOptions { Subscriber = muxer.GetSubscriber(), Topic = "test-queue", LoggerFactory = Log }); var distributedLock = new CacheLockProvider(cache, messageBus, Log); await CanHaveMultipleQueueInstancesWithLockingImplAsync(distributedLock); }
public RedisMessageBusTests() { if (Settings.Current.RedisConnectionInfo == null) { return; } var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString()); _messageBus = new RedisMessageBus(muxer.GetSubscriber()); }
public override async Task CanHaveMultipleQueueInstancesWithLockingAsync() { var muxer = SharedConnection.GetMuxer(); using (var cache = new RedisCacheClient(muxer, loggerFactory: Log)) { using (var messageBus = new RedisMessageBus(muxer.GetSubscriber(), "test", loggerFactory: Log)) { var distributedLock = new CacheLockProvider(cache, messageBus, Log); await CanHaveMultipleQueueInstancesWithLockingImplAsync(distributedLock); } } }
public void TearDown() { _testCache.Dispose(); _messageBus.Dispose(); _cacheLayer1.Dispose(); _cacheLayer2.Dispose(); _testCache = null; _messageBus = null; _cacheLayer1 = null; _cacheLayer2 = null; }
public async Task CanDisposeCacheAndQueueAndReceiveSubscribedMessages() { var muxer = SharedConnection.GetMuxer(); var messageBus1 = new RedisMessageBus(new RedisMessageBusOptions { Subscriber = muxer.GetSubscriber(), Topic = "test-messages", LoggerFactory = Log }); var cache = new RedisCacheClient(new RedisCacheClientOptions { ConnectionMultiplexer = muxer }); Assert.NotNull(cache); var queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem> { ConnectionMultiplexer = muxer, LoggerFactory = Log }); Assert.NotNull(queue); using (messageBus1) { using (cache) { using (queue) { await cache.SetAsync("test", "test", TimeSpan.FromSeconds(10)); await queue.DequeueAsync(new CancellationToken(true)); var countdown = new AsyncCountdownEvent(2); await messageBus1.SubscribeAsync <SimpleMessageA>(msg => { Assert.Equal("Hello", msg.Data); countdown.Signal(); }); await messageBus1.PublishAsync(new SimpleMessageA { Data = "Hello" }); await countdown.WaitAsync(TimeSpan.FromSeconds(2)); Assert.Equal(1, countdown.CurrentCount); cache.Dispose(); queue.Dispose(); await messageBus1.PublishAsync(new SimpleMessageA { Data = "Hello" }); await countdown.WaitAsync(TimeSpan.FromSeconds(2)); Assert.Equal(0, countdown.CurrentCount); } } } }
public async void ConnectionFailedChangesStateToClosed() { var redisConnection = GetMockRedisConnection(); var redisMessageBus = new RedisMessageBus(new Mock <Infrastructure.IStringMinifier>().Object, new TestLoggerFactory(), new Infrastructure.PerformanceCounterManager(new TestLoggerFactory()), new MessageBusOptionsAccessor(), new RedisOptionsAccessor(), redisConnection.Object, false); await redisMessageBus.ConnectWithRetry(); Assert.Equal(RedisMessageBus.State.Connected, redisMessageBus.ConnectionState); redisConnection.Raise(mock => mock.ConnectionFailed += null, new Exception("Test exception")); Assert.Equal(RedisMessageBus.State.Closed, redisMessageBus.ConnectionState); }
public async void ConnectionFailedChangesStateToClosed() { var redisConnection = GetMockRedisConnection(); var redisMessageBus = new RedisMessageBus(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty), redisConnection.Object, false); await redisMessageBus.ConnectWithRetry(); Assert.Equal(RedisMessageBus.State.Connected, redisMessageBus.ConnectionState); redisConnection.Raise(mock => mock.ConnectionFailed += null, new Exception("Test exception")); Assert.Equal(RedisMessageBus.State.Closed, redisMessageBus.ConnectionState); }
public static IServiceCollection AddMessageBus(this IServiceCollection services) { services.AddSingleton(provider => { var options = provider.GetRequiredService <IOptions <MessageBusOptions> >().Value; var type = options.Type.ToLower(); IMessageBus client; if (type == "auto") { var redisOptions = provider.GetRequiredService <IOptions <RedisOptions> >().Value; type = !string.IsNullOrEmpty(redisOptions.ConnectionString) ? "redis" : "memory"; } switch (type) { case "inmemory": case "memory": client = new InMemoryMessageBus(new InMemoryMessageBusOptions { LoggerFactory = provider.GetRequiredService <ILoggerFactory>(), Serializer = provider.GetRequiredService <ISerializer>() }); break; case "redis": client = new RedisMessageBus(new RedisMessageBusOptions { Subscriber = provider.GetRequiredService <IConnectionMultiplexer>().GetSubscriber(), LoggerFactory = provider.GetRequiredService <ILoggerFactory>(), Serializer = provider.GetRequiredService <ISerializer>() }); break; default: throw new NotSupportedException($"The cache type {options.Type} is not supported."); } return(client); }); return(services); }
public void RestoreLatestValueForKeyCalledOnConnectionRestored() { bool restoreLatestValueForKey = false; var redisConnection = GetMockRedisConnection(); redisConnection.Setup(m => m.RestoreLatestValueForKey(It.IsAny <int>(), It.IsAny <string>())).Returns(() => { restoreLatestValueForKey = true; return(TaskAsyncHelper.Empty); }); var redisMessageBus = new RedisMessageBus(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty), redisConnection.Object, true); redisConnection.Raise(mock => mock.ConnectionRestored += null, new Exception()); Assert.True(restoreLatestValueForKey, "RestoreLatestValueForKey not invoked"); }
public async void RestoreLatestValueForKeyCalledOnConnectionRestored() { bool restoreLatestValueForKey = false; var redisConnection = GetMockRedisConnection(); redisConnection.Setup(m => m.RestoreLatestValueForKey(It.IsAny <int>(), It.IsAny <string>())).Returns(() => { restoreLatestValueForKey = true; return(Task.FromResult <object>(null)); }); var redisMessageBus = new RedisMessageBus(new Mock <IStringMinifier>().Object, new TestLoggerFactory(), new PerformanceCounterManager(new TestLoggerFactory()), new MessageBusOptionsAccessor(), new RedisOptionsAccessor(), redisConnection.Object, false); await redisMessageBus.ConnectWithRetry(); redisConnection.Raise(mock => mock.ConnectionRestored += null, new Exception()); Assert.True(restoreLatestValueForKey, "RestoreLatestValueForKey not invoked"); }
public void SetUp() { var connectionString = ConfigurationManager.AppSettings.Get("RedisConnectionString"); _messageBus = new RedisMessageBus(connectionString); }
public void RestoreLatestValueForKeyCalledOnConnectionRestored() { bool restoreLatestValueForKey = false; var redisConnection = GetMockRedisConnection(); redisConnection.Setup(m => m.RestoreLatestValueForKey(It.IsAny<int>(), It.IsAny<string>())).Returns(() => { restoreLatestValueForKey = true; return TaskAsyncHelper.Empty; }); var redisMessageBus = new RedisMessageBus(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty), redisConnection.Object, true); redisConnection.Raise(mock => mock.ConnectionRestored += null, new Exception()); Assert.True(restoreLatestValueForKey, "RestoreLatestValueForKey not invoked"); }