private static CacheAttribute GetCacheSettings(IMethodInvocation input) { //get the cache attribute & check if overridden in config: var attributes = input.MethodBase.GetCustomAttributes(typeof(CacheAttribute), false); var cacheAttribute = (CacheAttribute)attributes[0]; var cacheKeyPrefix = CacheKeyBuilder.GetCacheKeyPrefix(input); var targetConfig = CacheConfiguration.Current.Targets[cacheKeyPrefix]; if (targetConfig != null) { cacheAttribute.Disabled = !targetConfig.Enabled; cacheAttribute.Days = targetConfig.Days; cacheAttribute.Hours = targetConfig.Hours; cacheAttribute.Minutes = targetConfig.Minutes; cacheAttribute.Seconds = targetConfig.Seconds; cacheAttribute.CacheType = targetConfig.CacheType; cacheAttribute.SerializationFormat = targetConfig.SerializationFormat; } if (cacheAttribute.SerializationFormat == SerializationFormat.Null) { cacheAttribute.SerializationFormat = CacheConfiguration.Current.DefaultSerializationFormat; } if (cacheAttribute.CacheType == CacheType.Null) { cacheAttribute.CacheType = CacheConfiguration.Current.DefaultCacheType; } return(cacheAttribute); }
public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext) { string key = CacheKeyBuilder.GetCacheKey(input, new BinarySerializer()); key = key.Replace(".", string.Empty); if (Defaults.TipoInicio == 4 && IsInCache(key + "return")) { var res = FetchFromCache(key + "return"); GetArgumentToCache(input, key); return(input.CreateMethodReturn(res, GetArgument(input))); } IMethodReturn methodReturn = getNext()(input, getNext); if (!input.MethodBase.ToString().Contains("System.Threading.Task") && Utility.ReflectionHelper.IsSerializable(input.MethodBase) && Defaults.HabilitarDistribuidorCache == "1") { if (methodReturn != null && methodReturn.ReturnValue != null && methodReturn.Exception == null) { AddToCache(key + "return", methodReturn); } AddArgumentToCache(input, key); } return(methodReturn); }
public Cache(IDatabase cache) : base(cache) { KeyFn = query => { return(CacheKeyBuilder.Build <GetJobs, Query>(query, m => m.UserId, m => m.PaginationParams.Page, m => m.PaginationParams.PerPage)); }; }
public IActionResult Index() { var authenticated = User.Identity?.IsAuthenticated ?? false; var viewModel = _cacheClient.GetOrCreate( CacheKeyBuilder.Build(nameof(ArchiveController), nameof(Index), authenticated), () => { var posts = _blogService.GetAllPosts().Where(x => x.Raw.IsPostPublished() || authenticated) .ToList(); var model = new List <PostArchiveViewModel>(); foreach (var item in posts.GroupBy(x => x.Raw.PublishTime.Year).OrderByDescending(y => y.Key)) { var archiveViewModel = new PostArchiveViewModel { Count = item.Count(), Posts = item.ToList(), Link = $"{item.Key}", Name = $"{item.Key}年" }; model.Add(archiveViewModel); } return(model); }); ViewData["Title"] = "存档"; ViewData["Image"] = $"{_blogOptions.BlogRemoteEndpoint}/archive.png"; ViewData["Description"] = "所有文章的存档。"; return(View("Index", viewModel)); }
protected override void GetConnectionKey(CacheKeyBuilder ckb) { base.GetConnectionKey(ckb); ckb.Add(DataSourceName); ckb.Add(Login); ckb.Add(Password); }
/// <summary> /// Performs a validation if current type of margin trading is enabled globally and for the particular client /// (which is extracted from the action parameters). /// Skips validation if current action method is marked with <see cref="SkipMarginTradingEnabledCheckAttribute"/>. /// </summary> /// <exception cref="InvalidOperationException"> /// Using this type of margin trading is restricted for client or /// a controller action has more then one ClientId in its parameters. /// </exception> private async Task ValidateMarginTradingEnabledAsync(ActionExecutingContext context) { var controllerActionDescriptor = context.ActionDescriptor as ControllerActionDescriptor; if (controllerActionDescriptor == null) { return; } var cacheKey = CacheKeyBuilder.Create(nameof(MarginTradingEnabledFilter), nameof(GetSingleClientIdGetter), controllerActionDescriptor.DisplayName); var clientIdGetter = _cacheProvider.Get(cacheKey, () => new CachableResult <ClientIdGetter>(GetSingleClientIdGetter(controllerActionDescriptor), CachingParameters.InfiniteCache)); if (clientIdGetter != null) { var clientId = clientIdGetter(context.ActionArguments); if (string.IsNullOrWhiteSpace(clientId)) { await _log.WriteWarningAsync(nameof(MarginTradingEnabledFilter), nameof(ValidateMarginTradingEnabledAsync), context.ActionDescriptor.DisplayName, "ClientId is null but is expected. No validation will be performed"); } else if (!await _marginTradingSettingsCacheService.IsMarginTradingEnabled(clientId, _marginSettings.IsLive)) { throw new InvalidOperationException("Using this type of margin trading is restricted for client " + clientId); } } }
protected TReturn CommandExecute <TReturn>(bool?enableCache, Func <TReturn> execQuery, string sql, object param, string cacheKey, TimeSpan?expire, int?pageIndex = default, int?pageSize = default) { if (!IsEnableCache(enableCache)) { return(execQuery()); } cacheKey = CacheKeyBuilder.Generate(sql, param, cacheKey, pageIndex, pageSize); Logger.LogDebug("Get query results from cache."); var cache = Cache.TryGet <TReturn>(cacheKey); if (cache.ExistKey) { Logger.LogDebug("Get value from cache successfully."); return(cache.Value); } Logger.LogDebug("The cache does not exist, acquire a lock, queue to query data from the database."); lock (Lock) { Logger.LogDebug("The lock has been acquired, try again to get the value from the cache."); var cacheResult = Cache.TryGet <TReturn>(cacheKey); if (cacheResult.ExistKey) { Logger.LogDebug("Try again, get value from cache successfully."); return(cacheResult.Value); } Logger.LogDebug("Try again, still fail to get the value from the cache, start to get the value from the data."); var result = execQuery(); Cache.TrySet(cacheKey, result, expire ?? CacheConfiguration.Expire); Logger.LogDebug("Get value from data and write to cache."); return(result); } }
public IActionResult Sitemap() { var sitemap = _cacheClient.GetOrCreate(CacheKeyBuilder.Build(nameof(HomeController), nameof(Sitemap)), () => { var sb = new StringBuilder(); sb.AppendLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); sb.AppendLine("<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">"); sb.AppendLine( $"<url><loc>{_blogOptions.BlogRemoteEndpoint}</loc><lastmod>{DateTime.Now.ToDate()}</lastmod><changefreq>daily</changefreq><priority>1.0</priority></url>"); sb.AppendLine( $"<url><loc>{_blogOptions.BlogRemoteEndpoint}/read</loc><lastmod>{DateTime.Now.ToDate()}</lastmod><changefreq>daily</changefreq><priority>0.9</priority></url>"); sb.AppendLine( $"<url><loc>{_blogOptions.BlogRemoteEndpoint}/about</loc><lastmod>{DateTime.Now.ToDate()}</lastmod><changefreq>daily</changefreq><priority>0.9</priority></url>"); sb.AppendLine( $"<url><loc>{_blogOptions.BlogRemoteEndpoint}/archive</loc><lastmod>{DateTime.Now.ToDate()}</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>"); sb.AppendLine( $"<url><loc>{_blogOptions.BlogRemoteEndpoint}/tag</loc><lastmod>{DateTime.Now.ToDate()}</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>"); foreach (var post in _blogService.GetAllPosts().Where(x => x.Raw.IsPostPublished())) { sb.AppendLine( $"<url><loc>{post.Raw.GetFullPath(_blogOptions.BlogRemoteEndpoint)}</loc><lastmod>{post.Raw.LastUpdateTime.ToDate()}</lastmod><changefreq>daily</changefreq><priority>0.6</priority></url>"); } sb.AppendLine("</urlset>"); return(sb.ToString()); }); return(Content(sitemap, "text/xml", Encoding.UTF8)); }
/// <summary> /// Performs a validation if current type of margin trading is enabled globally and for the particular client /// (which is extracted from the action parameters). /// </summary> /// <exception cref="InvalidOperationException"> /// Using this type of margin trading is restricted for client or /// a controller action has more then one AccountId in its parameters. /// </exception> private void ValidateMarginTradingEnabled(ActionExecutingContext context) { if (!(context.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor)) { return; } var cacheKey = CacheKeyBuilder.Create(nameof(MarginTradingEnabledFilter), nameof(GetSingleAccountIdGetter), controllerActionDescriptor.DisplayName); var accountIdGetter = _cacheProvider.Get(cacheKey, () => new CachableResult <AccountIdGetter>(GetSingleAccountIdGetter(controllerActionDescriptor), CachingParameters.InfiniteCache)); if (accountIdGetter != null) { var accountId = accountIdGetter(context.ActionArguments); if (!string.IsNullOrWhiteSpace(accountId)) { var isAccEnabled = _marginTradingSettingsCacheService.IsMarginTradingEnabledByAccountId(accountId); if (isAccEnabled == null) { throw new InvalidOperationException($"Account {accountId} does not exist"); } if (!(bool)isAccEnabled) { throw new InvalidOperationException( $"Using this type of margin trading is restricted for account {accountId}. Error Code: {CommonErrorCodes.AccountDisabled}"); } } } }
private async Task UpdateMemoryPostsAsync() { var memPosts = GetPosts(); var filePosts = await GetPostsFromFileAsync(); var posts = new List <BlogPost>(); foreach (var filePost in filePosts) { if (StringEqualsHelper.IgnoreCase(filePost.GitHubPath, BlogConstant.TemplatePostGitHubPath)) { continue; } var memPost = memPosts.FirstOrDefault(p => StringEqualsHelper.IgnoreCase(p.Link, filePost.Link)); if (memPost != null) { filePost.Visits = Math.Max(filePost.Visits, memPost.Visits); } posts.Add(filePost); } _memoryCacheClient.Set(CacheKeyBuilder.Build(SiteComponent.Blog, "post", "all"), posts); }
/// <summary> /// Returns previously cached response or invokes method and caches response /// </summary> /// <param name="input"></param> /// <param name="getNext"></param> /// <returns></returns> public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext) { //if caching is disabled, leave: if (!CacheConfiguration.Current.Enabled) { return(Proceed(input, getNext)); } //get the cache settings from the attribute & config: var cacheAttribute = GetCacheSettings(input); if (cacheAttribute.Disabled) { return(Proceed(input, getNext)); } //if there's no cache provider, leave: var cache = Cache.Get(cacheAttribute.CacheType); var serializer = Serializer.GetCurrent(cacheAttribute.SerializationFormat); if (cache == null || cache.CacheType == CacheType.Null || serializer == null) { return(Proceed(input, getNext)); } // Log cache request here var returnType = ((MethodInfo)input.MethodBase).ReturnType; var cacheKey = CacheKeyBuilder.GetCacheKey(input, serializer); var cachedValue = cache.Get(returnType, cacheKey, cacheAttribute.SerializationFormat); if (cachedValue == null) { // missed the cache // Log here for instrumentation //call the intended method to set the return value var methodReturn = Proceed(input, getNext); //only cache if we have a real return value & no exception: if (methodReturn != null && methodReturn.ReturnValue != null && methodReturn.Exception == null) { var lifespan = cacheAttribute.Lifespan; if (lifespan.TotalSeconds > 0) { cache.Set(cacheKey, methodReturn.ReturnValue, lifespan, cacheAttribute.SerializationFormat); } else { cache.Set(cacheKey, methodReturn.ReturnValue, cacheAttribute.SerializationFormat); } } return(methodReturn); } else { // hit the cache // Log here for instrumentation } return(input.CreateMethodReturn(cachedValue)); }
public async Task SetsCorrectCacheEntry_WhenOptimizeRouteResultIsSuccess_AndRequestOrderIsUpdated() { var optimizeRouteService = new Mock <IOptimizeRouteService>(); optimizeRouteService.Setup(x => x.OptimizeRoute(It.IsAny <OptimizeRouteCriteria>())) .ReturnsAsync(new OptimizeRouteResult { Distance = 10, Duration = 10, RequestIds = new List <Guid> { Request4Id, Request1Id } }); var cache = new MemoryCache(new MemoryCacheOptions()); var sut = new OptimizeRouteCommandHandler(Context, optimizeRouteService.Object, cache); await sut.Handle(new OptimizeRouteCommand { ItineraryId = 1, UserId = "123" }); var expectedCacheKey = CacheKeyBuilder.BuildOptimizeRouteCacheKey("123", 1); OptimizeRouteResultStatus cachedStatus = null; var keyExists = cache.TryGetValue(expectedCacheKey, out cachedStatus); keyExists.ShouldBeTrue(); cachedStatus.IsSuccess.ShouldBeTrue(); cachedStatus.StatusMessage.ShouldBe(OptimizeRouteStatusMessages.OptimizeSucess); }
public Cache(IDatabase cache) : base(cache) { KeyFn = query => { return(CacheKeyBuilder.Build <GetChats, Query>(query, m => m.UserId)); }; }
//public override bool IsSingleDatabase //{ // get { return m_isSingleDatabase; } //} //[XmlElem("IsSingleDatabase")] //public bool IsSingleDatabase_Origin //{ // get { return m_isSingleDatabase; } // set { m_isSingleDatabase = value; } //} //[XmlElem] //public override string ExplicitDatabaseName { get; set; } protected override void GetConnectionKey(CacheKeyBuilder ckb) { base.GetConnectionKey(ckb); ckb.Add(ConnectionString); ckb.Add(FactoryName); ckb.Add(DriverName); }
public void Clear(long userId) { UserDataChangeTime.Update(userId, DateTime.UtcNow); foreach (var k in CacheKeyBuilder.GetAllKeys(userId)) { cache.Remove(k); } }
public override void GetConnectionKey(CacheKeyBuilder ckb) { ckb.Add(Encoding); ckb.Add(EncodingStyle); ckb.Add(Url); ckb.Add(HttpLogin); ckb.Add(HttpPassword); }
public List <BlogCategory> GetCategories() { if (!_memoryCacheClient.TryGet <List <BlogCategory> >(CacheKeyBuilder.Build(SiteComponent.Blog, "category", "all"), out var categories)) { categories = new List <BlogCategory>(); } return(categories); }
public List <BlogPost> GetPosts() { if (!_memoryCacheClient.TryGet <List <BlogPost> >(CacheKeyBuilder.Build(SiteComponent.Blog, "post", "all"), out var posts)) { posts = new List <BlogPost>(); } return(posts); }
public List <BlogTag> GetTags() { if (!_memoryCacheClient.TryGet <List <BlogTag> >(CacheKeyBuilder.Build(SiteComponent.Blog, "tag", "all"), out var tags)) { tags = new List <BlogTag>(); } return(tags); }
private void SetOptimizeCache(string userId, int itineraryId, OptimizeRouteResultStatus message) { if (!string.IsNullOrEmpty(userId)) { var cacheEntryOptions = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(1)); _cache.Set(CacheKeyBuilder.BuildOptimizeRouteCacheKey(userId, itineraryId), message, cacheEntryOptions); } }
/// <summary>Gets a People by Id.</summary> /// <param name="key">The key.</param> /// <returns>The People.</returns> public Entities.People Get(int key) { var cacheKey = new CacheKeyBuilder("People.Service.V1_0_0").New(key); var result = CacheGateway.Instance() .Get(cacheKey, () => this.context.PeopleSet.FirstOrDefault(x => x.Id == key)); return result; }
public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext) { #region Check cache is enabled if (!CacheConfiguration.Current.Enabled) { return(Proceed(input, getNext)); } #endregion #region NoCache is checking var nocache = input.MethodBase.GetCustomAttributes(typeof(NoCacheAttribute), false); if (nocache.Count() != 0) { return(Proceed(input, getNext)); } #endregion #region Instanciate AppFabric Cache. if it is no working, return. var cache = Caching.Cache.AppFabric; if (cache == null /* or cache is disabled inside the webconfig*/) { return(Proceed(input, getNext)); } #endregion ExpireRegions(input, cache); #region Check Void Methods if (((MethodInfo)input.MethodBase).ReturnType.Name == "Void") // specific behavior for Void Methods { return(Proceed(input, getNext)); } #endregion #region Check the Cache string cacheKey = CacheKeyBuilder.GetCacheKey(input); string region = CacheKeyBuilder.GetRegion(input); var cachedValue = cache.Get(cacheKey, region); if (cachedValue == null) { var methodReturn = Proceed(input, getNext); if (methodReturn != null && methodReturn.ReturnValue != null && methodReturn.Exception == null) { cache.Set(cacheKey, region, methodReturn.ReturnValue); } return(methodReturn); } else { return(input.CreateMethodReturn(cachedValue)); } #endregion }
private async Task UpdateMemoryAboutAsync() { var zhAbout = await GetAboutFromFileAsync(RequestLang.Chinese); _memoryCacheClient.Set(CacheKeyBuilder.Build(SiteComponent.Blog, "about", RequestLang.Chinese), zhAbout); var enAbout = await GetAboutFromFileAsync(RequestLang.English); _memoryCacheClient.Set(CacheKeyBuilder.Build(SiteComponent.Blog, "about", RequestLang.English), enAbout); }
public string GetAboutHtml(RequestLang lang = RequestLang.Chinese) { var cacheKey = CacheKeyBuilder.Build(SiteComponent.Blog, "about", lang); if (!_memoryCacheClient.TryGet <string>(cacheKey, out var html)) { html = string.Empty; } return(html); }
public void ShouldCreateFromObjectProperties() { var sut = new { A = 1, B = "abc", C = (object)null, D = new[] { 1, 2, 3 } }; Assert.Equal("{1}{abc}{}{:1:2:3:}", CacheKeyBuilder.CreateFromObjectProperties(sut)); }
public void ShouldCreate() { Assert.AreEqual("{A}", CacheKeyBuilder.Create("A")); Assert.AreEqual("{A}{B}", CacheKeyBuilder.Create("A", "B")); Assert.AreEqual("{A}{B}{C}", CacheKeyBuilder.Create("A", "B", "C")); Assert.AreEqual("{A}{}{C}", CacheKeyBuilder.Create("A", null, "C")); Assert.AreEqual("{:1:2:3:}", CacheKeyBuilder.Create(new[] { 1, 2, 3 })); Assert.AreEqual("{A}{:1:2:3:}", CacheKeyBuilder.Create("A", new[] { 1, 2, 3 })); Assert.AreEqual("{A}{B}{:1:2:3:}", CacheKeyBuilder.Create("A", "B", new[] { 1, 2, 3 })); Assert.AreEqual("{A}{B}{:1:2:3:}{C}", CacheKeyBuilder.Create("A", "B", new[] { 1, 2, 3 }, "C")); Assert.AreEqual("{A}{}{:1:2:3:}{}", CacheKeyBuilder.Create("A", null, new[] { 1, 2, 3 }, null)); Assert.AreEqual("{A}{::1:2:::3:4:::5:6::}", CacheKeyBuilder.Create("A", new[] { new[] { 1, 2 }, new[] { 3, 4 }, new[] { 5, 6 } })); }
protected override void GetConnectionKey(CacheKeyBuilder ckb) { base.GetConnectionKey(ckb); ckb.Add(DataSource); ckb.Add(Login); ckb.Add(CharacterSet); ckb.Add(Password); ckb.Add(Port); if (TunnelDriver != null) { TunnelDriver.GetConnectionKey(ckb); } }
public IActionResult Rss() { var rss = _cacheClient.GetOrCreate(CacheKeyBuilder.Build(nameof(HomeController), nameof(Rss)), () => { var feed = new SyndicationFeed(Constants.BlogTitle, Constants.BlogDescription, new Uri($"{_blogOptions.BlogRemoteEndpoint}/rss"), Constants.ApplicationName, DateTimeOffset.UtcNow) { Copyright = new TextSyndicationContent( $"&amp;#169; {DateTime.Now.Year} {_blogOptions.AdminChineseName}") }; feed.Authors.Add(new SyndicationPerson(_blogOptions.AdminEmail, _blogOptions.AdminChineseName, _blogOptions.BlogRemoteEndpoint)); feed.BaseUri = new Uri(_blogOptions.BlogRemoteEndpoint); feed.Language = "zh-cn"; var items = new List <SyndicationItem>(); foreach (var post in _blogService.GetAllPosts().Where(x => x.Raw.IsPostPublished())) { items.Add(new SyndicationItem(post.Raw.Title, post.HtmlContent, new Uri(post.Raw.GetFullPath(_blogOptions.BlogRemoteEndpoint)), post.Raw.GetFullPath(_blogOptions.BlogRemoteEndpoint), new DateTimeOffset(post.Raw.LastUpdateTime, TimeSpan.FromHours(8)))); } feed.Items = items; var settings = new XmlWriterSettings { Encoding = Encoding.UTF8, NewLineHandling = NewLineHandling.Entitize, NewLineOnAttributes = false, Async = true, Indent = true }; using var ms = new MemoryStream(); using (var xmlWriter = XmlWriter.Create(ms, settings)) { var rssFormatter = new Rss20FeedFormatter(feed, false); rssFormatter.WriteTo(xmlWriter); xmlWriter.Flush(); } return(Encoding.UTF8.GetString(ms.ToArray())); }); return(Content(rss, "application/rss+xml", Encoding.UTF8)); }
public override void Set(string key, object value, DateTime expiresAt) { try { var itemBytes = Serializer.Binary.Serialize(value) as byte[]; var item = new CacheItem() { ItemBytes = itemBytes }; var serializedItem = Serializer.Json.Serialize(item); var cacheKey = CacheKeyBuilder.GetCacheKey(key); Current.SetInternal(cacheKey, serializedItem, expiresAt); } catch (Exception ex) { //Log.Warn("CacheBase.Set - failed, item not cached. Message: {0}", ex.Message); } }
protected TReturn CommandExecute <TReturn>(bool?enableCache, Func <TReturn> execQuery, string sql, object param, string cacheKey, TimeSpan?expire, int?pageIndex = default, int?pageSize = default) { if (!IsEnableCache(enableCache)) { return(execQuery()); } cacheKey = CacheKeyBuilder.Generate(sql, param, cacheKey, pageIndex, pageSize); var cache = Cache.TryGet <TReturn>(cacheKey); if (cache.HasKey) { return(cache.Value); } var result = execQuery(); Cache.TrySet(cacheKey, result, expire ?? CacheConfiguration.Expire); return(result); }
public IActionResult Index([FromQuery] int page) { var authenticated = User.Identity?.IsAuthenticated ?? false; var viewModel = _cacheClient.GetOrCreate( CacheKeyBuilder.Build(nameof(HomeController), nameof(Index), page, authenticated), () => { var posts = _blogService.GetAllPosts().Where(x => x.Raw.IsPostPublished() || authenticated).ToList(); var toppedPosts = posts.Where(x => x.Raw.IsTopping).ToList(); foreach (var blogPost in toppedPosts) { posts.Remove(blogPost); } posts.InsertRange(0, toppedPosts); var postsPerPage = Convert.ToInt32(_blogOptions.PostsPerPage); var model = new PagedViewModel <PostViewModel>(page, posts.Count, postsPerPage) { Url = Request.Path }; foreach (var blogPost in posts.Chunk(postsPerPage).ElementAtOrDefault(model.CurrentPage - 1) ?? Enumerable.Empty <BlogPostRuntime>()) { var postViewModel = new PostViewModel { Current = blogPost }; postViewModel.SetAdditionalInfo(); model.Items.Add(postViewModel); } return(model); }); if (viewModel.CurrentPage > 1) { ViewData["RobotsEnabled"] = false; ViewData["Title"] = $"首页:第{viewModel.CurrentPage}页"; } return(View(viewModel)); }
public ICacheKeyBuilder CreateKey() { var builder = new CacheKeyBuilder(_tagManager); return builder; }