public async Task CancelScenario() { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var service = new LockService(library, new Internals.Locks.IdentifierGenerator()); var root = Guid.NewGuid().ToString().Substring(0, 8); var key = new Key(root, "name", TimeSpan.FromSeconds(2)); var db = connection.GetDatabase(); await ResetKeys(db, key); try { using var cancel = new CancellationTokenSource(); cancel.CancelAfter(500); try { await service.LockAsync(key, c => Task.Delay(1000, c), cancel.Token); } catch (Exception e) { Assert.IsType <TaskCanceledException>(e.InnerException?.InnerException ?? e.InnerException ?? e); } Assert.False(await db.KeyExistsAsync(key.GetLockKey())); Assert.False(await db.KeyExistsAsync(key.GetLockQueueKey())); Assert.False(await db.KeyExistsAsync(key.GetLockQueueSetKey())); } finally { await ResetKeys(db, key); } }
public async Task SimpleScenario() { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var service = new LockService(library, new Internals.Locks.IdentifierGenerator()); var root = Guid.NewGuid().ToString().Substring(0, 8); var key = new Key(root, "name", TimeSpan.FromSeconds(1)); var result = false; var db = connection.GetDatabase(); await ResetKeys(db, key); try { await service.LockAsync(key, c => { result = true; return(Task.CompletedTask); }, CancellationToken.None); Assert.True(result); Assert.False(await db.KeyExistsAsync(key.GetLockKey())); Assert.False(await db.KeyExistsAsync(key.GetLockQueueKey())); Assert.False(await db.KeyExistsAsync(key.GetLockQueueSetKey())); } finally { await ResetKeys(db, key); } }
public async Task PublishTests(object value) { var connection = ConfigurationHelper.GetNewConnection(); var library = new MemoScriptLibrary(connection); var db = connection.GetDatabase(); var root = Guid.NewGuid().ToString().Substring(0, 8); var key = new MemoKey(root, "key", TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)); var parameters = new MemoSetValueParameters(key, RedisValue.Unbox(value)); try { await ResetKeys(db, parameters); var message = RedisValue.Null; await connection.GetSubscriber().SubscribeAsync(parameters.MemoChannelKey, (c, v) => message = v); await library.PublishAsync(parameters); await Task.Delay(500); var expectedValue = value == null ? RedisValue.EmptyString : RedisValue.Unbox(value); Assert.Equal(expectedValue, message); Assert.Equal(expectedValue, await db.StringGetAsync(parameters.MemoKey)); } finally { await ResetKeys(db, parameters); } }
public async Task ConcurrencyScenario() { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var service = new LockService(library, new Internals.Locks.IdentifierGenerator()); var root = Guid.NewGuid().ToString().Substring(0, 8); var key = new Key(root, "name", TimeSpan.FromSeconds(5)); var db = connection.GetDatabase(); var events = new ConcurrentQueue <string>(); var concurrencyScenarioCounter = 0; var errorCount = 0; var counter = 0; await ResetKeys(db, key); try { var watch = new Stopwatch(); var tasks = Enumerable.Range(0, 100).Select(i => service.LockAsync(key, async c => { Interlocked.Increment(ref concurrencyScenarioCounter); events.Enqueue($"{i:d3} in at {watch.ElapsedMilliseconds:d4}ms thread id {Thread.CurrentThread.ManagedThreadId}"); if (concurrencyScenarioCounter != 1) { watch.Stop(); Interlocked.Increment(ref errorCount); throw new Exception($"Lock failed after {watch.ElapsedMilliseconds}" + Environment.NewLine + string.Join(Environment.NewLine, events)); } Interlocked.Increment(ref counter); await Task.Delay(10); events.Enqueue($"{i:d3} out at {watch.ElapsedMilliseconds:d4}ms thread id {Thread.CurrentThread.ManagedThreadId}"); Interlocked.Decrement(ref concurrencyScenarioCounter); }, CancellationToken.None)); watch.Start(); await Task.WhenAll(tasks); Assert.Equal(100, counter); Assert.Equal(0, errorCount); Assert.False(await db.KeyExistsAsync(key.GetLockKey())); Assert.False(await db.KeyExistsAsync(key.GetLockQueueKey())); Assert.False(await db.KeyExistsAsync(key.GetLockQueueSetKey())); } finally { await ResetKeys(db, key); } }
public async Task SubscribeTests() { var connection = ConfigurationHelper.GetNewConnection(); var library = new MemoScriptLibrary(connection); var db = connection.GetDatabase(); var timeout = 500; var root = Guid.NewGuid().ToString().Substring(0, 8); var key = new MemoKey(root, "key", TimeSpan.FromMilliseconds(timeout), TimeSpan.FromSeconds(1)); var result = false; await library.SubscribeAsync(key.GetSubscribtionChannel(), (c, v) => result = true); await db.PublishAsync(key.GetValueChannel(), "identifier"); await Task.Delay(30); Assert.True(result); }
public async Task SubscribeTests() { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var db = connection.GetDatabase(); var root = Guid.NewGuid().ToString().Substring(0, 8); var key = new Key(root, "name", TimeSpan.FromSeconds(2)); using var context = new LockState(key, "identifier", CancellationToken.None); await library.SubscribeAsync(context); await db.PublishAsync(key.GetLockChannelKey(), "identifier"); await Task.Delay(500); Assert.Equal(State.WithKey, context.State);//proof that the message was received await library.UnSubscribeAsync(context); }
public async Task GetKeySituationTests(string priorValue, string waiting, int expected) { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var db = connection.GetDatabase(); //SETUP var root = Guid.NewGuid().ToString().Substring(0, 8); var parameters = new LockLuaParameters("id", new Key(root, "name", TimeSpan.FromMilliseconds(500))); try { await ResetKeys(db, parameters); if (!string.IsNullOrEmpty(priorValue)) { await db.StringSetAsync(parameters.LockKey, priorValue); } if (!string.IsNullOrEmpty(waiting)) { await db.HashSetAsync(parameters.LockWaitingSetKey, waiting, 0); } //ACT var result = await library.GetKeySituation(parameters); var exists = await db.HashExistsAsync(parameters.LockWaitingSetKey, parameters.Identifier); Assert.Equal(expected, result); } finally { await ResetKeys(db, parameters); } }
public async Task FreeLockAndPopScriptTests(string priorValue, string waiting) { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var db = connection.GetDatabase(); //SETUP var root = Guid.NewGuid().ToString().Substring(0, 8); var parameters = new LockLuaParameters("id", new Key(root, "name", TimeSpan.FromMilliseconds(500))); try { await ResetKeys(db, parameters); if (!string.IsNullOrEmpty(priorValue)) { await db.StringSetAsync(parameters.LockKey, priorValue, TimeSpan.FromMilliseconds(parameters.Timeout)); } if (!string.IsNullOrEmpty(waiting)) { await db.HashSetAsync(parameters.LockWaitingSetKey, waiting, 0); await db.ListRightPushAsync(parameters.LockWaitingListKey, waiting); } var message = ""; await connection.GetSubscriber().SubscribeAsync(parameters.LockNotifKey, (a, b) => message = b); //ACT await library.FreeLockAndPop(parameters); var locked = await db.StringGetAsync(parameters.LockKey); Assert.NotEqual(parameters.Identifier, (string)locked); if (priorValue == parameters.Identifier) { if (waiting != "") { Assert.Equal(waiting, locked); Assert.NotNull(await db.KeyTimeToLiveAsync(parameters.LockKey)); //doesn't work somehow //Assert.NotNull(await db.KeyTimeToLiveAsync(parameters.LockWaitingListKey)); //Assert.NotNull(await db.KeyTimeToLiveAsync(parameters.LockWaitingSetKey)); await Task.Delay(50); Assert.Equal(message, waiting); await Task.Delay(450); Assert.False(await db.KeyExistsAsync(parameters.LockKey)); Assert.False(await db.KeyExistsAsync(parameters.LockWaitingListKey)); Assert.False(await db.KeyExistsAsync(parameters.LockWaitingSetKey)); } else { Assert.Equal(RedisValue.Null, locked); Assert.False(await db.KeyExistsAsync(parameters.LockKey)); Assert.False(await db.KeyExistsAsync(parameters.LockWaitingListKey)); Assert.False(await db.KeyExistsAsync(parameters.LockWaitingSetKey)); } } } finally { await ResetKeys(db, parameters); } }
public async Task GetLockOrSubscribeTests(string priorValue, string waiting, bool expectedResult) { var connection = ConfigurationHelper.GetNewConnection(); var library = new ScriptLibrary(connection); var db = connection.GetDatabase(); //SETUP var root = Guid.NewGuid().ToString().Substring(0, 8); var parameters = new LockLuaParameters("id", new Key(root, "name", TimeSpan.FromMilliseconds(500))); try { await ResetKeys(db, parameters); if (!string.IsNullOrEmpty(priorValue)) { await db.StringSetAsync(parameters.LockKey, priorValue, TimeSpan.FromMilliseconds(parameters.Timeout)); } if (!string.IsNullOrEmpty(waiting)) { await db.HashSetAsync(parameters.LockWaitingSetKey, waiting, 0); await db.KeyExpireAsync(parameters.LockWaitingSetKey, TimeSpan.FromMilliseconds(parameters.Timeout)); await db.ListRightPushAsync(parameters.LockWaitingListKey, waiting); await db.KeyExpireAsync(parameters.LockWaitingListKey, TimeSpan.FromMilliseconds(parameters.Timeout)); } //ACT var result = await library.GetLockOrAddToQueue(parameters); //ASSERT Assert.Equal(expectedResult, result); if (expectedResult) { Assert.Equal(parameters.Identifier, await db.StringGetAsync(parameters.LockKey)); Assert.Equal(!string.IsNullOrEmpty(waiting), await db.KeyExistsAsync(parameters.LockWaitingListKey)); Assert.Equal(!string.IsNullOrEmpty(waiting), await db.KeyExistsAsync(parameters.LockWaitingSetKey)); } else { var lockKey = (string)await db.StringGetAsync(parameters.LockKey); Assert.NotEmpty(lockKey); Assert.NotEqual(parameters.Identifier, lockKey); Assert.Contains(parameters.Identifier, await db.ListRangeAsync(parameters.LockWaitingListKey)); Assert.Contains(parameters.Identifier, (await db.HashGetAllAsync(parameters.LockWaitingSetKey)).Select(e => e.Name)); } //expiration delay await Task.Delay((int)parameters.Timeout + 50); Assert.False(await db.KeyExistsAsync(parameters.LockKey)); Assert.False(await db.KeyExistsAsync(parameters.LockWaitingListKey)); Assert.False(await db.KeyExistsAsync(parameters.LockWaitingSetKey)); } finally { await ResetKeys(db, parameters); } }