public void Serialized_Caching(Type serializerType) {
            var serializer = (ISerializer)ActivatorTool.CreateInstance(serializerType);
            var repository = new MemcachedRepository(serializer);

            var tasks = new List<TaskCacheItem>();
            var cachedTasks = new List<TaskCacheItem>();

            for(var i = 0; i < 10; i++) {
                var task = new TaskCacheItem()
                           {
                               IsDone = false,
                               Summary = "Task " + i + " to cached.",
                               Data = ArrayTool.GetRandomBytes(0x0100)
                           };

                tasks.Add(task);
                repository.Set(task.Id.ToString(), task);
            }

            foreach(var task in tasks) {
                var cachedTask = repository.Get(task.Id.ToString()) as TaskCacheItem;

                cachedTask.Should().Not.Be.Null();
                cachedTasks.Add(cachedTask);
            }
        }
        public void Serialized_Caching(Type serializerType)
        {
            var serializer = (ISerializer)ActivatorTool.CreateInstance(serializerType);
            var repository = new SharedCacheRepository(serializer);

            var tasks       = new List <TaskCacheItem>();
            var cachedTasks = new List <TaskCacheItem>();

            for (var i = 0; i < 10; i++)
            {
                var task = new TaskCacheItem()
                {
                    IsDone  = false,
                    Summary = "Task " + i + " to cached.",
                    Data    = ArrayTool.GetRandomBytes(0x2000)
                };

                tasks.Add(task);
                repository.Set(task.Id.ToString(), task);
            }

            foreach (var task in tasks)
            {
                var cachedTask = repository.Get(task.Id.ToString()) as TaskCacheItem;

                cachedTask.Should().Not.Be.Null();
                cachedTasks.Add(cachedTask);
            }
        }
        public void Can_Add_And_Load_Task() {
            Cache.Clear();

            var task = new TaskCacheItem
                       {
                           IsDone = false,
                           Summary = @"Task to cached.",
                           Data = ArrayTool.GetRandomBytes(0x2000)
                       };

            var taskId = task.Id.ToString();

            Cache.Add(taskId, task);
            taskIdStrs.Add(taskId);

            var tasks = Cache.GetAllKeys().Select(key => Cache.Get<TaskCacheItem>(key)).ToList();

            Assert.IsTrue(tasks.Any(t => t.IsDone == false));

            var retrieved = Cache.Get<TaskCacheItem>(taskId);
            Assert.IsNotNull(retrieved);
            Assert.AreEqual(taskId, retrieved.Id.ToString());

            Cache.Clear();

            if(Cache.GetAllKeys().Contains(taskId)) {
                retrieved = Cache.Get(taskId) as TaskCacheItem;
                Assert.IsNull(retrieved);
            }
        }
 public void Can_Add_And_Load_Task() {
     var task = new TaskCacheItem()
                {
                    IsDone = false,
                    Summary = "Task to cached."
                };
     _repository.Set(Guid.NewGuid().ToString(), task);
 }
Beispiel #5
0
        public void AddTask(TaskCacheItem taskCacheItem) {
            taskCacheItem.ShouldNotBeNull("task");
            taskCacheItem.Validate();
            taskCacheItem.Id.ShouldNotBeNull("Task.Id");
            taskCacheItem.Id.ShouldNotBeEquals(Guid.Empty, "Task.Id");

            taskCacheItem.CreateDate = DateTime.UtcNow; // PrevalenceEngine.Now;

            var added = _tasks.TryAdd(taskCacheItem.Id, taskCacheItem);

            if(IsDebugEnabled)
                log.Debug("Task를 캐시에 저장을 시도했습니다. 저장여부={0}, Task={1}", added, taskCacheItem);
        }
Beispiel #6
0
        public void MassiveInsert(int taskCount) {
            for(var i = 0; i < taskCount; i++) {
                var item = new TaskCacheItem
                           {
                               IsDone = false,
                               Summary = "Task " + i + " to cached.",
                               Data = ArrayTool.GetRandomBytes(DataSize)
                           };

                Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(5));
            }

            var stats = IndexusDistributionCache.SharedCache.GetStats();
        }
        public void MassiveInsert(int taskCount)
        {
            for (var i = 0; i < taskCount; i++)
            {
                var item = new TaskCacheItem
                {
                    IsDone  = false,
                    Summary = "Task " + i + " to cached.",
                    Data    = ArrayTool.GetRandomBytes(DataSize)
                };

                Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(5));
            }

            var stats = IndexusDistributionCache.SharedCache.GetStats();
        }
        public void MassiveInsertAsync(int taskCount)
        {
            var tasks = new List <Task>();

            for (var i = 0; i < taskCount; i++)
            {
                var item = new TaskCacheItem
                {
                    IsDone  = false,
                    Summary = "Task " + i + " to cached.",
                    Data    = ArrayTool.GetRandomBytes(DataSize)
                };

                var task = Task.Factory.StartNew(() => Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(5)));
                tasks.Add(task);
            }

            Task.WaitAll(tasks.ToArray());

            var stats = IndexusDistributionCache.SharedCache.GetStats();
        }
        public void ExpirationTest(int taskCount)
        {
            TaskCacheItem item;

            for (var i = 0; i < taskCount; i++)
            {
                item = new TaskCacheItem()
                {
                    IsDone  = false,
                    Summary = "Task " + i + " to cached.",
                    Data    = ArrayTool.GetRandomBytes(DataSize)
                };

                Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(1));
            }

            Thread.Sleep(TimeSpan.FromSeconds(2));

            item = new TaskCacheItem()
            {
                IsDone  = false,
                Summary = "Task xxxx to cached.",
                Data    = ArrayTool.GetRandomBytes(DataSize)
            };

            Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(1));

            Thread.Sleep(TimeSpan.FromSeconds(2));

            item = new TaskCacheItem()
            {
                IsDone  = false,
                Summary = "Task xxxx to cached.",
                Data    = ArrayTool.GetRandomBytes(DataSize)
            };

            Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(1));

            var stats = IndexusDistributionCache.SharedCache.GetStats();
        }
Beispiel #10
0
        public void ExpirationTest(int taskCount) {
            TaskCacheItem item;

            for(var i = 0; i < taskCount; i++) {
                item = new TaskCacheItem()
                       {
                           IsDone = false,
                           Summary = "Task " + i + " to cached.",
                           Data = ArrayTool.GetRandomBytes(DataSize)
                       };

                Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(1));
            }

            Thread.Sleep(TimeSpan.FromSeconds(2));

            item = new TaskCacheItem()
                   {
                       IsDone = false,
                       Summary = "Task xxxx to cached.",
                       Data = ArrayTool.GetRandomBytes(DataSize)
                   };

            Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(1));

            Thread.Sleep(TimeSpan.FromSeconds(2));

            item = new TaskCacheItem()
                   {
                       IsDone = false,
                       Summary = "Task xxxx to cached.",
                       Data = ArrayTool.GetRandomBytes(DataSize)
                   };

            Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(1));

            var stats = IndexusDistributionCache.SharedCache.GetStats();
        }
Beispiel #11
0
        public void Can_Add_Multiple_And_Clear() {
            Cache.Clear();
            taskIdStrs.Clear();

            const int TaskCount = 1000;

            for(int i = 0; i < TaskCount; i++) {
                var task = new TaskCacheItem()
                           {
                               IsDone = false,
                               Summary = "Task " + i + " to cached.",
                               Data = ArrayTool.GetRandomBytes(0x2000)
                           };

                Cache.Add(task.Id.ToString(), task);
                taskIdStrs.Add(task.Id.ToString());
            }

            Assert.AreEqual(TaskCount, Cache.GetAllKeys().Count);

            foreach(var taskId in taskIdStrs)
                Assert.IsNotNull(Cache.Get(taskId), "캐시에 해당 키의 정보가 없습니다. taskId=" + taskId);
        }
Beispiel #12
0
        public void MassiveInsertAsync(int taskCount) {
            var tasks = new List<Task>();

            for(var i = 0; i < taskCount; i++) {
                var item = new TaskCacheItem
                           {
                               IsDone = false,
                               Summary = "Task " + i + " to cached.",
                               Data = ArrayTool.GetRandomBytes(DataSize)
                           };

                var task = Task.Factory.StartNew(() => Cache.Add(item.Id.ToString(), item, DateTime.Now.AddSeconds(5)));
                tasks.Add(task);
            }

            Task.WaitAll(tasks.ToArray());

            var stats = IndexusDistributionCache.SharedCache.GetStats();
        }