Example #1
0
        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);
        }
Example #2
0
 public HybridCacheClient(ConnectionMultiplexer connectionMultiplexer)
 {
     _redisCache          = new RedisCacheClient(connectionMultiplexer);
     _localCache.MaxItems = 100;
     _messageBus          = new RedisMessageBus(connectionMultiplexer.GetSubscriber(), "cache");
     _messageBus.Subscribe <InvalidateCache>(OnMessage);
 }
Example #3
0
        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());   
        }
Example #5
0
        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);
        }
Example #6
0
        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 RedisMessageBusTests()
        {
            //if (!Settings.Current.UseAzureServiceBus)
            //    return;

            var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());

            _messageBus = new RedisMessageBus(muxer.GetSubscriber());
        }
Example #10
0
        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());
        }
Example #12
0
        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);
                    }
                }
            }
        }
Example #15
0
        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);
        }
Example #16
0
        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);
        }
Example #17
0
        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);
        }
Example #18
0
        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);
        }
Example #19
0
        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");
        }
Example #20
0
        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");
        }
Example #21
0
 public void SetUp()
 {
     var connectionString = ConfigurationManager.AppSettings.Get("RedisConnectionString");
     _messageBus = new RedisMessageBus(connectionString);
 }
Example #22
0
        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");
        }