public void RedisLockAllowsWaitingAndWakingALock() { using (var storage = new RedisStorage(Host)) { var lockKey = Guid.NewGuid().ToString(); bool isWaiting = false; bool isFinished = false; var waitingThread = new Thread(() => { using (var @lock = storage.AcquireLock(lockKey)) { isWaiting = true; @lock.Wait(); } isFinished = true; }); waitingThread.Start(); TestHelpers.RepeatUntilTrue(() => isWaiting, times: 5); isWaiting.ShouldBe(true); isFinished.ShouldBe(false); using (var anotherLock = storage.AcquireLock(lockKey)) { anotherLock.PulseAll(); } TestHelpers.RepeatUntilTrue(() => isFinished, times: 5); isFinished.ShouldBe(true); } }
public void OpenXesSerializationTest() { var storage = new RedisStorage(Host); var key = Guid.NewGuid().ToString(); var list = new DistributedList<EventType>(storage, key); list.Add(new EventType("Start", "Start", DateTime.Now, EventType.Transition.Start)); list.Add(new EventType("Start", "Start", DateTime.Now.AddSeconds(1), EventType.Transition.Complete)); list.Add(new EventType("Phone Call", "Helen", DateTime.Now.AddSeconds(2), EventType.Transition.Start)); list.Add(new EventType("Phone Call", "Helen", DateTime.Now.AddSeconds(3), EventType.Transition.Complete)); list.Add(new EventType("End", "End", DateTime.Now.AddSeconds(4), EventType.Transition.Start)); list.Add(new EventType("End", "End", DateTime.Now.AddSeconds(5), EventType.Transition.Complete)); storage = new RedisStorage(Host); list = new DistributedList<EventType>(storage, key); var localList = list.ToList(); localList.Count.ShouldBe(6); localList.Where(e => e != null).Count().ShouldBe(6); var @case = new TraceType(Guid.NewGuid().ToString(), list); var log = LogType.Create(new[] { @case }); var xml = log.Serialize(); Assert.IsTrue(xml.Contains("Phone Call")); }
public FetchedJobsWatcherFacts() { var options = new RedisStorageOptions() { Db = RedisUtils.GetDb() }; _storage = new RedisStorage(RedisUtils.GetHostAndPort(), options); _cts = new CancellationTokenSource(); _cts.Cancel(); }
public void DefaultCtor_InitializesCorrectDefaultValues() { using (var storage = new RedisStorage()) { Assert.Equal(0, storage.Db); } }
public void DefaultCtor_InitializesCorrectDefaultValues() { var storage = new RedisStorage(); Assert.True(storage.ConnectionString.Contains("localhost:6379")); Assert.Equal(0, storage.Db); }
public void ConnectionOptions() { var configOptions = ConfigurationOptions.Parse(TestConfig.Current.RedisConnectionString); var storage = new RedisStorage(configOptions); storage.GetUnviewedIds(""); }
public void Multiplexer() { var multiplexer = ConnectionMultiplexer.Connect("localhost:6379"); var storage = new RedisStorage(multiplexer); storage.GetUnviewedIds(""); }
public void Register(Container container) { container.RegisterSingleton<IEventReciever, EventReciever>(); container.RegisterSingleton<IEventSender, EventSender>(); var eventDispatcherRegistration = Lifestyle.Singleton.CreateRegistration(() => { var rdb = new RedisDatabase( new RedisConnection(ConfigurationManager.ConnectionStrings["RedisServer"].ConnectionString), int.Parse(ConfigurationManager.AppSettings["redisApiResultStorageDb"])); var redisStorage = new RedisStorage<AsyncResultContainer<dynamic>>(rdb, null, "result:{0:D}"); return new EventDispatcher( container.GetInstance<IEventSender>(), redisStorage); }, container); container.AddRegistration(typeof(EventDispatcher), eventDispatcherRegistration); var storageProviderRegistration = Lifestyle.Singleton.CreateRegistration(() => new StorageProvider(new RedisDatabase( new RedisConnection(ConfigurationManager.ConnectionStrings["RedisServer"].ConnectionString), int.Parse(ConfigurationManager.AppSettings["redisEventStorageDb"]))), container); container.AddRegistration(typeof(StorageProvider), storageProviderRegistration); container.AddRegistration(typeof(IModelElementStorage), storageProviderRegistration); container.RegisterSingleton<ManagerDependencyResolver>(new ManagerDependencyResolver(x => ((IServiceProvider)container).GetService(x))); container.RegisterSingleton<ScriptEngine>(); container.RegisterSingleton<Engine>(); container.RegisterSingleton<ApplicationProxyBase, EventApplicationProxy>(); }
private RateLimitProcessor <SimulationRequest> GetTokenBucketProcessor(string storageType) { var tokenBucketRules = new TokenBucketRateLimitRule <SimulationRequest>[] { new TokenBucketRateLimitRule <SimulationRequest>(30, 10, TimeSpan.FromSeconds(1)) { Id = Guid.NewGuid().ToString(), LockSeconds = 1, ExtractTarget = (request) => { return(request.RequestResource); }, CheckRuleMatching = (request) => { return(true); }, } }; IRateLimitStorage storage = new InProcessMemoryStorage(); if (storageType == "redis") { storage = new RedisStorage(StackExchange.Redis.ConnectionMultiplexer.Connect("127.0.0.1")); } return(new RateLimitProcessor <SimulationRequest> .Builder() .WithAlgorithm(new TokenBucketAlgorithm <SimulationRequest>(tokenBucketRules)) .WithStorage(storage) .WithError(new RateLimitError() { Code = 429, }) .Build()); }
public override bool OnExecution() { var value = this.InParameters["value"].GetValue().ToString(); RedisStorage.SetGraphKeyItem(this.Graph, this.InParameters["key"].GetValue().ToString(), value); return(true); }
public void DefaultCtor_InitializesCorrectDefaultValues() { var storage = new RedisStorage(); Assert.Equal("localhost:6379", storage.HostAndPort); Assert.Equal(0, storage.Db); }
public static void UpdateAliveStorage() { var lists = _graphs.Where(x => !x.Value.graph.Debug && x.Value.currentGraphState == GraphStateEnum.STARTED || x.Value.currentGraphState == GraphStateEnum.RESTARTING).ToList().Select(x => x.Value.graph).ToList(); RedisStorage.SaveListActiveGraphs(lists); }
public async Task getOne_returnSpecifiedId() { var storage = new RedisStorage(_redisConnection); var client = await storage.GetOne(_client.Id); Assert.AreEqual(client.Id, _client.Id); }
public ErrorWorkerProcess(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _logger = _serviceProvider.GetService <ILogger <ErrorWorkerProcess> >(); _options = _serviceProvider.GetService <RedisMessageBusOptions>(); _redisStorage = _serviceProvider.GetService <RedisStorage>(); }
public void Multiplexer() { var multiplexer = ConnectionMultiplexer.Connect(TestConfig.Current.RedisConnectionString); var storage = new RedisStorage(multiplexer); storage.GetUnviewedIds(""); }
public void DistributedDictionaryHandlesDistributedListAsValue() { var storage = new RedisStorage(Host); var id = Guid.NewGuid().ToString(); var dictionary = new Bluepath.Storage.Structures.Collections.DistributedDictionary<int, Bluepath.Storage.Structures.Collections.DistributedList<string>>(storage, id); var distributedList1 = new Bluepath.Storage.Structures.Collections.DistributedList<string>(storage, Guid.NewGuid().ToString()); var distributedList2 = new Bluepath.Storage.Structures.Collections.DistributedList<string>(storage, Guid.NewGuid().ToString()); distributedList1.Add("jack"); distributedList1.Add("checked"); distributedList1.Add("chicken"); distributedList2.Add("in"); distributedList2.Add("the"); dictionary.Add(0, distributedList1); dictionary.Add(1, distributedList2); var dictionaryCheck = new Bluepath.Storage.Structures.Collections.DistributedDictionary<int, Bluepath.Storage.Structures.Collections.DistributedList<string>>(storage, id); dictionaryCheck.Count.ShouldBe(2); var checkList1 = dictionaryCheck[0]; //checkList1.Storage = storage; var checkList2 = dictionaryCheck[1]; //checkList2.Storage = storage; checkList1.Count.ShouldBe(3); checkList2.Count.ShouldBe(2); checkList1[0].ShouldBe("jack"); }
public async Task getAll_returnAllItens() { var storage = new RedisStorage(_redisConnection); var clients = await storage.GetAll(); Assert.AreEqual(1, clients.Count()); }
public static ServerSetup UseRedisStorage(this ServerSetup setup, string connectionString, RedisStorageOptions options = null) { if (setup == null) { throw new ArgumentNullException(nameof(setup)); } if (string.IsNullOrEmpty(connectionString)) { throw new ArgumentNullException(nameof(connectionString)); } var redisOptions = ConfigurationOptions.Parse(connectionString); options = options ?? new RedisStorageOptions { Db = redisOptions.DefaultDatabase ?? 0 }; var connectionMultiplexer = ConnectionMultiplexer.Connect(connectionString); var storage = new RedisStorage(connectionMultiplexer, options); setup.Register <IStorage>(storage); return(setup); }
public static bool InitActiveGraphs() { var graphStorages = RedisStorage.GetGraphStorages(); logger.Info("Starting back the context of {0} graph(s) from last execution", graphStorages.Count); graphStorages.ForEach(x => { try { var decompressedRaw = GraphCompression.DecompressGraphData(x.CompressedBytes); var loadedGraph = BlockGraph.LoadGraph(decompressedRaw, x.StoredHash, x.CompressedBytes); if (loadedGraph != null) { AddNewGraph(loadedGraph, x.WalletIdentifierOwner, x.StateGraph, true); } } catch (Exception error) { logger.Error(error); } }); return(true); }
private static ICodeStorage GetRedisStorage() { var multiplexer = ConnectionMultiplexer.Connect("127.0.0.1:6379"); var storage = new RedisStorage(multiplexer); return(storage); }
public void CoordinatorWorks() { //Bluepath.Log.ClearXes(); using (var redisStorage = new RedisStorage(Host)) { this.storage = new BluepathStorage(redisStorage); this.storage.Clean(); this.storage.Store("f1", "ala ma kota"); this.storage.Store("f2", "kota alama"); this.storage.Store("f3", "dolan ma"); var filesToRead = this.storage.ListFiles(); var mapperCodeFile = new FileUri("file:///SampleMapper.cs"); var reducerCodeFile = new FileUri("file:///SampleReducer.cs"); TestHelpers.LoadToStorage(@"..\..\SampleMapper.cs", mapperCodeFile, this.storage); TestHelpers.LoadToStorage(@"..\..\SampleReducer.cs", reducerCodeFile, this.storage); var connectionManager = new ConnectionManager(new Dictionary<ServiceUri, PerformanceStatistics>(), null, null, null); var scheduler = new ThreadNumberScheduler(connectionManager); var coordinator = new Coordinator(connectionManager, scheduler, DistributedThread.ExecutorSelectionMode.LocalOnly); coordinator.Start(2, 2, mapperCodeFile, reducerCodeFile, filesToRead.Select(f => new FileUri(f.ToString()))); string result = string.Empty; Debug.WriteLine("Listing files..."); foreach (var file in this.storage.ListFiles()) { var fileName = this.storage.GetFileName(file); Debug.Write(fileName); try { Debug.WriteLine(" -- {0}", (object)Base64Decode(fileName)); } catch { Debug.WriteLine(string.Empty); } } foreach (var uri in this.storage.ListFiles()) { var file = this.storage.GetFileName(uri); if (file.Contains("REDUCE") && file.Contains("kota")) { result = this.storage.Read(file); Debug.WriteLine("File '{0}' contains '{1}'.", file, result); } } result.ShouldBe("2"); this.storage.Clean(); } System.Threading.Thread.Sleep(3000); //Bluepath.Log.SaveXes(@"c:\temp\bluepath.xes", clearListAfterSave: true); //Bluepath.Log.ClearXes(); }
public void IDatabase() { var multiplexer = ConnectionMultiplexer.Connect("localhost:6379"); var database = multiplexer.GetDatabase(); var storage = new RedisStorage(database); storage.GetUnviewedIds(""); }
public void RedisStorage_Set() { var storage = new RedisStorage(_multiplexer.Object); storage.Set(new StorageKey("storage", "key"), "value"); _db.Verify(exp => exp.HashSetAsync(It.IsAny <RedisKey>(), new[] { new HashEntry("value".GetType().Name, "value") }, CommandFlags.None), Times.Once); }
public RedisConnectionFacts() { var options = new RedisStorageOptions() { }; _storage = new RedisStorage(RedisUtils.RedisClient, options); }
public void RedisStorage_AddToList() { var storage = new RedisStorage(_multiplexer.Object); storage.AddToList(new StorageKey("storage", "key"), new { Value = "value" }); _db.Verify(exp => exp.ListRightPushAsync(It.IsAny <RedisKey>(), new RedisValue("{Value: 'value'}"), When.Always, CommandFlags.None), Times.Once); }
public void IDatabase() { var multiplexer = ConnectionMultiplexer.Connect(TestConfig.Current.RedisConnectionString); var database = multiplexer.GetDatabase(); var storage = new RedisStorage(database); storage.GetUnviewedIds(""); }
public RedisWriteOnlyTransactionFacts() { var options = new RedisStorageOptions() { }; _storage = new RedisStorage(RedisUtils.RedisClient, options); }
public WorkerProcess(IServiceProvider serviceProvider, string topic) { _serviceProvider = serviceProvider; _logger = _serviceProvider.GetService <ILogger <WorkerProcess> >(); _options = _serviceProvider.GetService <RedisMessageBusOptions>(); _topic = topic; _redisStorage = _serviceProvider.GetService <RedisStorage>(); }
/// <summary> /// Tells the bootstrapper to use Redis as a job storage /// available at localhost:6379 and use the '0' db to store /// the data. /// </summary> public static RedisStorage UseRedisStorage( this IBootstrapperConfiguration configuration) { var storage = new RedisStorage(); configuration.UseStorage(storage); return storage; }
public RedisFetchedJobFacts() { var options = new RedisStorageOptions() { }; _storage = new RedisStorage(RedisUtils.RedisClient, options); }
public RedisConnectionFacts() { var options = new RedisStorageOptions() { Db = RedisUtils.GetDb() }; _storage = new RedisStorage(RedisUtils.GetHostAndPort(), options); }
public DelayedWorkProcess(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _logger = _serviceProvider.GetService <ILogger <DelayedWorkProcess> >(); _options = _serviceProvider.GetService <RedisMessageBusOptions>(); _redisStorage = _serviceProvider.GetService <RedisStorage>(); PreReadSecond = _options.DelayTaskPreReadSecond; }
/// <summary> /// Tells the bootstrapper to use Redis as a job storage /// available at the specified host and port and store the /// data in db with number '0'. /// </summary> /// <param name="configuration">Configuration</param> /// <param name="hostAndPort">Host and port, for example 'localhost:6379'</param> public static RedisStorage UseRedisStorage( this IBootstrapperConfiguration configuration, string hostAndPort) { var storage = new RedisStorage(hostAndPort); configuration.UseStorage(storage); return storage; }
/// <summary> /// Tells the bootstrapper to use Redis as a job storage /// available at localhost:6379 and use the '0' db to store /// the data. /// </summary> public static RedisStorage UseRedisStorage( this IBootstrapperConfiguration configuration) { var storage = new RedisStorage(); configuration.UseStorage(storage); return(storage); }
public override object ComputeParameterValue(NodeParameter parameter, object value) { if (parameter.Name == "value") { return(RedisStorage.GetGraphKeyItem(this.Graph, this.InParameters["key"].GetValue().ToString())); } return(base.ComputeParameterValue(parameter, value)); }
static void Main(string[] args) { Boot.Start(); ICacheStorage storage = new RedisStorage(); storage.Subscrib(OrderStaticResource.CREATE_ORDER_CHANGEQTY_CHANNELNAME, Handler); Console.ReadLine(); }
public void DistributedCounterInitialCountIsAsIndicated() { using (var storage = new RedisStorage(Host)) { var id = Guid.NewGuid().ToString(); var counter = new DistributedCounter(storage, id, 18); counter.GetValue().ShouldBe(18); } }
public void ConnectionOptions() { var storage = new RedisStorage(new ConfigurationOptions { EndPoints = { { "localhost", 6379 } } }); storage.GetUnviewedIds(""); }
public void RedisStorageDoesntAllowUpdatingNotExistingObject() { var objectToStore = "my object"; var objectName = Guid.NewGuid().ToString(); using (var storage = new RedisStorage(RedisStorageTests.Host)) { Assert.That(() => storage.Update(objectName, objectToStore), Throws.Exception); } }
public void RedisStorageDoesntAllowDuplicateStoreWithStoreMethod() { var objectToStore = "my object"; var objectName = Guid.NewGuid().ToString(); using (var storage = new RedisStorage(RedisStorageTests.Host)) { storage.Store(objectName, objectToStore); Assert.That(() => storage.Store(objectName, objectToStore), Throws.Exception); } }
public void DistributedDictionaryAllowsAddingAndReadingEntries() { var storage = new RedisStorage(Host); var id = Guid.NewGuid().ToString(); var dictionary = new Bluepath.Storage.Structures.Collections.DistributedDictionary<int, string>(storage, id); dictionary.Add(0, "ala"); dictionary.Add(2, "ola"); dictionary.Add(18, "zuza"); dictionary[18].ShouldBe("zuza"); }
public void GetStateHandlers_ReturnsAllHandlers() { var storage = new RedisStorage(); var handlers = storage.GetStateHandlers(); var handlerTypes = handlers.Select(x => x.GetType()).ToArray(); Assert.Contains(typeof(FailedStateHandler), handlerTypes); Assert.Contains(typeof(ProcessingStateHandler), handlerTypes); Assert.Contains(typeof(SucceededStateHandler), handlerTypes); Assert.Contains(typeof(DeletedStateHandler), handlerTypes); }
public void DistributedCounterSharesStateBetweenInstancesWithTheSameId() { using(var storage = new RedisStorage(Host)) { var id = Guid.NewGuid().ToString(); var counter1 = new DistributedCounter(storage, id); var counter2 = new DistributedCounter(storage, id); counter1.SetValue(23); counter2.GetValue().ShouldBe(23); counter2.Decrease(1); counter1.GetValue().ShouldBe(22); } }
public void RedisStorageStoresAndRemovesObjects() { var objectToStore = "my object"; var objectName = Guid.NewGuid().ToString(); using (var storage = new RedisStorage(RedisStorageTests.Host)) { storage.Store(objectName, objectToStore); storage.Remove(objectName); Assert.That(() => storage.Retrieve<string>(objectName), Throws.InstanceOf<ArgumentOutOfRangeException>()); } }
public void AcquireDistributedLock_MultiStorage() { UseConnection(connection => { var SecondStorage = new RedisStorage(Redis.ServerInfo, new RedisStorageOptions() { Db = Redis.Storage.Db }); using (var lock1 = connection.AcquireDistributedLock("some-hash:lock", TimeSpan.FromSeconds(1))) { Assert.Throws<TimeoutException>(() => { var lock2 = SecondStorage.GetConnection().AcquireDistributedLock("some-hash:lock", TimeSpan.FromMilliseconds(10)); }); } }); }
public void RedisLockAllowsAcquireAfterReleaseTimeout() { using (var storage = new RedisStorage(Host)) { var lockKey = Guid.NewGuid().ToString(); var @lock = storage.AcquireLock(lockKey); @lock.IsAcquired.ShouldBe(true); @lock.Release(); @lock.IsAcquired.ShouldBe(false); @lock.Acquire(); @lock.IsAcquired.ShouldBe(true); @lock.Dispose(); } }
public void RedisLockAllowsAcquireWithTimeout() { using (var storage = new RedisStorage(Host)) { var lockKey = Guid.NewGuid().ToString(); using (var @lock = storage.AcquireLock(lockKey)) { IStorageLock anotherLock; var acquireResult = storage.AcquireLock(lockKey, TimeSpan.FromMilliseconds(10), out anotherLock); acquireResult.ShouldBe(false); anotherLock.IsAcquired.ShouldBe(false); } } }
public void DistributedDictionaryAllowsRemovingEntries() { var storage = new RedisStorage(Host); var id = Guid.NewGuid().ToString(); var dictionary = new Bluepath.Storage.Structures.Collections.DistributedDictionary<int, string>(storage, id); dictionary.Add(0, "ala"); dictionary.Add(2, "ola"); dictionary.Add(18, "zuza"); dictionary.ContainsKey(2).ShouldBe(true); dictionary.Remove(2); dictionary.ContainsKey(2).ShouldBe(false); }
public void DistributedListAllowsAddingEnumerablesInOneStep() { var storage = new RedisStorage(Host); var key = Guid.NewGuid().ToString(); var list = new DistributedList<int>(storage, key); var localList = new List<int>(); for (int i = 0; i < 10; i++) { localList.Add(i); } list.AddRange(localList); list.Count.ShouldBe(10); }
public void FileSystemStorageRemoveDeletesGivenFile() { using (var redisStorage = new RedisStorage(Host)) { var storage = new BluepathStorage(redisStorage, eraseContents: true); storage.Store("a", "aa"); storage.Store("b", "bb"); var fileToRemove = storage.ListFiles().First(u => u.OriginalString.Contains("a")); storage.Remove(fileToRemove); var noOfFiles = storage.ListFiles().Count(); noOfFiles.ShouldBe(1); storage.ListFiles().First().OriginalString.ShouldContain("b"); } }
public void DLINQPerformsDistributedGroupBy() { bool isFailed = false; BluepathListener listener1; BluepathListener listener2; ConnectionManager connectionManager; Log.TraceMessage(Log.Activity.Custom,string.Format("GroupBy test lift off!")); PrepareDLINQEnviroment(out listener1, out listener2, out connectionManager); try { var inputCollection = new List<string>(); for (int i = 0; i < 100; i++) { inputCollection.Add(string.Format("{0}{1}", (i % 2 == 0 ? "a" : "b"), i)); } var locallyGrouped = inputCollection.GroupBy(s => s[0]); var localDict = locallyGrouped.ToDictionary(g => g.Key, g => g); var storage = new RedisStorage(Host); var groupedCollection = inputCollection.AsDistributed(storage, connectionManager) .GroupBy(s => s[0]); Log.TraceMessage(Log.Activity.Custom,"GroupBy Begin actual processing"); var processedCollection = groupedCollection.ToDictionary(g => g.Key, g => g); Log.TraceMessage(Log.Activity.Custom,"GroupBy processing finished, begin asserts"); processedCollection.Keys.Count.ShouldBe(2); processedCollection['a'].Count().ShouldBe(localDict['a'].Count()); processedCollection['b'].Count().ShouldBe(localDict['b'].Count()); Log.TraceMessage(Log.Activity.Custom,"GroupBy test passed"); } catch (Exception ex) { Log.ExceptionMessage(ex, Log.Activity.Info); isFailed = true; } finally { listener1.Stop(); listener2.Stop(); Log.TraceMessage(Log.Activity.Custom, string.Format("GroupBy test finished, isFailed: {0}", isFailed)); if(isFailed) { Assert.Fail(); } } }
public void FileSystemStoragCleanMethodDeletesAllFiles() { using (var redisStorage = new RedisStorage(Host)) { var storage = new BluepathStorage(redisStorage, eraseContents: true); storage.Store("a", "aa"); storage.Store("b", "bb"); var noOfFiles1 = storage.ListFiles().Count(); noOfFiles1.ShouldBe(2); storage.Clean(); var noOfFiles2 = storage.ListFiles().Count(); noOfFiles2.ShouldBe(0); } }
public void DistributedListHandlesBigCollections() { var storage = new RedisStorage(Host); var key = Guid.NewGuid().ToString(); var list = new DistributedList<int>(storage, key); int amount = 100000; var localList = new List<int>(amount); for (int i = 0; i < amount;i++ ) { localList.Add(i); } list.AddRange(localList); list.Count.ShouldBe(amount); list.Clear(); list.Count.ShouldBe(0); }
public void RedisStorageStoresAndRemovesObjectsInBulks() { KeyValuePair<string, string>[] objectsToStore = new KeyValuePair<string, string>[100]; for (int i = 0; i < objectsToStore.Length; i++) { objectsToStore[i] = new KeyValuePair<string, string>(Guid.NewGuid().ToString(), "jack checked chicken"); } using (var storage = new RedisStorage(RedisStorageTests.Host)) { storage.BulkStore(objectsToStore); storage.BulkRemove(objectsToStore.Select(o => o.Key).ToArray()); foreach (var @object in objectsToStore) { Assert.That(() => storage.Retrieve<string>(@object.Key), Throws.InstanceOf<ArgumentOutOfRangeException>()); } } }
public void DistributedListAllowsAddingAndRemovingItems() { var storage = new RedisStorage(Host); var key = Guid.NewGuid().ToString(); var list = new DistributedList<int>(storage, key); for (int i = 0; i < 10; i++) { list.Add(i); } list.Count.ShouldBe(10); list.Remove(5); list.Count.ShouldBe(9); foreach (var item in list) { item.ShouldNotBe(5); } }
public FetchedJobsWatcherFacts() { _storage = new RedisStorage(RedisUtils.GetHostAndPort(), RedisUtils.GetDb()); _cts = new CancellationTokenSource(); _cts.Cancel(); }
private void DifferentPrefix() { UseConnection(redis => { var SecondStorage = new RedisStorage(Redis.ServerInfo, new RedisStorageOptions { Db = Redis.Storage.Db, Prefix = "test:" }); var SecondConnection = SecondStorage.GetDatabase(); Commit(redis, x => x.InsertToList("some-list", "value")); var transaction = new RedisWriteOnlyTransaction(SecondConnection.CreateTransaction(), SecondStorage.GetSubscribe(), SecondStorage.Prefix); transaction.InsertToList("some-list", "value2"); transaction.Commit(); Assert.Equal(1, redis.ListLength(Prefix + "some-list")); Assert.Equal(1, SecondConnection.ListLength(SecondStorage.Prefix + "some-list")); Assert.Equal("value", redis.ListLeftPop(Prefix + "some-list")); Assert.Equal("value2", SecondConnection.ListLeftPop(SecondStorage.Prefix + "some-list")); }); }