public CacheCreationResult(bool wasUpdated, bool wasInserted, bool alreadyExisted, CacheValueOf <T> value, bool existsButWrongType = false)
     : base(wasUpdated, wasInserted)
 {
     AlreadyExisted     = alreadyExisted;
     Value              = value;
     ExistsButWrongType = existsButWrongType;
 }
示例#2
0
        private bool ModifyDocument <T>(Document doc, string key, CacheValueOf <T> cacheObject)
        {
            var cachePolicy = cacheObject.Policy;

            // TODO: Disabled for beta due to a bug in ServiceStack deserializing CompositeEntitySchema: var totalJson = SerializationService.ToJson(cacheObject);
            var jsonStream = _fixedSerializer.ToStream(cacheObject);

            if (!jsonStream.Success)
            {
                return(false);
            }

            var totalJson = jsonStream.ResultStream.ToJsonString();

            doc.Add(new Field("CacheKey", key, Field.Store.YES, Field.Index.NOT_ANALYZED));
            doc.Add(new Field("CacheEntry", totalJson, Field.Store.YES, Field.Index.NOT_ANALYZED));

            doc.Add(new NumericField("ExpiryTicks", Field.Store.YES, false).SetLongValue(cachePolicy.ExpiryDate.Ticks));

            var utcNow = DateTimeOffset.Now;

            doc.Add(new NumericField("Created", Field.Store.YES, false).SetLongValue(utcNow.Ticks));

            return(true);
        }
示例#3
0
        public override CacheModificationResult AddOrChange <T>(string key, CacheValueOf <T> cacheObject)
        {
            if (_useInMemoryCache)
            {
                _innerCacheProvider.AddOrChange(key, cacheObject);
            }

            var existing = GetCacheEntry(key, true);

            try
            {
                if (existing != null)
                {
                    _indexController.QueueRemoveWhere(new Term("CacheKey", key));
                }

                var doc = new Document();

                ModifyDocument(doc, key, cacheObject);

                LogHelper.TraceIfEnabled <CacheProvider>("Queueing an item to the index");
                _indexController.QueueAdd(doc);

                return(new CacheModificationResult(existing != null, existing == null));
            }
            finally
            {
                _removalCache.Remove(key);
            }
        }
示例#4
0
        public void CanSerializeCacheValueOfListOfRelations()
        {
            var relation1 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            var relation2 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            var relation3 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);

            var list = new List <IRelationById> {
                relation1, relation2, relation3
            };
            var cacheValueOf = new CacheValueOf <List <IRelationById> >(list);

            //Serialize
            var serializedKey = SerializationService.ToStream(cacheValueOf);
            var keyJson       = serializedKey.ResultStream.ToJsonString();
            //Deserialize
            var keyBack = SerializationService.FromStream(serializedKey.ResultStream, typeof(CacheValueOf <List <IRelationById> >));
            //Serialize again
            var serializedKeyBack = SerializationService.ToStream(keyBack);
            var keyJsonTwice      = serializedKeyBack.ResultStream.ToJsonString();

            Assert.That(keyBack, Is.Not.Null);
            Assert.That(keyJson, Is.EqualTo(keyJsonTwice));
        }
示例#5
0
        public void CanSerializeCacheValueOfIRelationById()
        {
            var relation1 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            var cacheValue = new CacheValueOf <IRelationById>(relation1);

            var json = SerializationService.ToJson(cacheValue);

            Assert.That(json, Is.Not.Empty);

            var rehydrate = SerializationService.FromJson <CacheValueOf <IRelationById> >(json);

            Assert.That(rehydrate, Is.Not.Null);

            Assert.That(rehydrate, Is.EqualTo(cacheValue));
        }
        public void CanSerializeCacheValueOfListOfRelations()
        {
            var relation1 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            var relation2 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            var relation3 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            
            var list = new List<IRelationById> {relation1, relation2, relation3};
            var cacheValueOf = new CacheValueOf<List<IRelationById>>(list);

            //Serialize
            var serializedKey = SerializationService.ToStream(cacheValueOf);
            var keyJson = serializedKey.ResultStream.ToJsonString();
            //Deserialize
            var keyBack = SerializationService.FromStream(serializedKey.ResultStream, typeof(CacheValueOf<List<IRelationById>>));
            //Serialize again
            var serializedKeyBack = SerializationService.ToStream(keyBack);
            var keyJsonTwice = serializedKeyBack.ResultStream.ToJsonString();

            Assert.That(keyBack, Is.Not.Null);
            Assert.That(keyJson, Is.EqualTo(keyJsonTwice));
        }
        public void CanSerializeCacheValueOfIRelationById()
        {
            var relation1 = new RelationById(new HiveId(Guid.NewGuid()), new HiveId(Guid.NewGuid()),
                                             FixedRelationTypes.DefaultRelationType, 0);
            var cacheValue = new CacheValueOf<IRelationById>(relation1);

            var json = SerializationService.ToJson(cacheValue);
            Assert.That(json, Is.Not.Empty);

            var rehydrate = SerializationService.FromJson<CacheValueOf<IRelationById>>(json);
            Assert.That(rehydrate, Is.Not.Null);

            Assert.That(rehydrate, Is.EqualTo(cacheValue));
        }
示例#8
0
 public override CacheModificationResult AddOrChange <T>(CacheKey key, CacheValueOf <T> cacheObject)
 {
     return(new CacheModificationResult(false, false));
 }