示例#1
0
        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);
            }
        }
示例#2
0
        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();
        }
示例#4
0
 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("");
        }
示例#7
0
        public void Multiplexer()
        {
            var multiplexer = ConnectionMultiplexer.Connect("localhost:6379");
            var storage     = new RedisStorage(multiplexer);

            storage.GetUnviewedIds("");
        }
示例#8
0
        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());
        }
示例#10
0
        public override bool OnExecution()
        {
            var value = this.InParameters["value"].GetValue().ToString();

            RedisStorage.SetGraphKeyItem(this.Graph, this.InParameters["key"].GetValue().ToString(), value);
            return(true);
        }
示例#11
0
        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);
        }
示例#13
0
        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");
        }
示例#17
0
        public void DefaultCtor_InitializesCorrectDefaultValues()
        {
            var storage = new RedisStorage();

            Assert.Equal("localhost:6379", storage.HostAndPort);
            Assert.Equal(0, storage.Db);
        }
 public void DefaultCtor_InitializesCorrectDefaultValues()
 {
     using (var storage = new RedisStorage())
     {
         Assert.Equal(0, storage.Db);
     }
 }
示例#19
0
        public async Task getAll_returnAllItens()
        {
            var storage = new RedisStorage(_redisConnection);
            var clients = await storage.GetAll();

            Assert.AreEqual(1, clients.Count());
        }
示例#20
0
        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);
        }
        public void DefaultCtor_InitializesCorrectDefaultValues()
        {
            var storage = new RedisStorage();

            Assert.True(storage.ConnectionString.Contains("localhost:6379"));
            Assert.Equal(0, storage.Db);
        }
示例#23
0
        private static ICodeStorage GetRedisStorage()
        {
            var multiplexer = ConnectionMultiplexer.Connect("127.0.0.1:6379");
            var storage     = new RedisStorage(multiplexer);

            return(storage);
        }
示例#24
0
        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();
        }
示例#25
0
        public void IDatabase()
        {
            var multiplexer = ConnectionMultiplexer.Connect("localhost:6379");
            var database    = multiplexer.GetDatabase();
            var storage     = new RedisStorage(database);

            storage.GetUnviewedIds("");
        }
示例#26
0
        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);
        }
示例#27
0
        public RedisConnectionFacts()
        {
            var options = new RedisStorageOptions()
            {
            };

            _storage = new RedisStorage(RedisUtils.RedisClient, options);
        }
示例#28
0
        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;
        }
示例#33
0
        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);
        }
示例#38
0
        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));
        }
示例#39
0
        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);
     }
 }
示例#41
0
        public void ConnectionOptions()
        {
            var storage = new RedisStorage(new ConfigurationOptions
            {
                EndPoints = { { "localhost", 6379 } }
            });

            storage.GetUnviewedIds("");
        }
示例#42
0
        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);
            }
        }
示例#43
0
        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);
     }
 }
示例#47
0
        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));
             });
         }
     });
 }
示例#49
0
 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();
     }
 }
示例#50
0
 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);
        }
示例#52
0
        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);
        }
示例#53
0
        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");
            }
        }
示例#54
0
        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();
                }
            }
        }
示例#55
0
        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);
            }
        }
示例#56
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);
        }
示例#57
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>());
                }
            }
        }
示例#58
0
        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"));
     });
 }