CheckClientRateLimitAsync(string clientid, string path)
        {
            var region      = _option.RedisKeyPrefix + "CheckClientRateLimitAsync";
            var key         = region + clientid + path;
            var cacheResult = _rateLimitRuleCache.Get(key, region);

            if (cacheResult != null)
            {
                //提取缓存数据
                return(cacheResult.RateLimit, cacheResult.RateLimitOptions);
            }
            else
            {
                //重新获取限流策略
                var result = await _clientRateLimitRepository.CheckClientRateLimitAsync(clientid, path);

                _rateLimitRuleCache.Add(key,
                                        new RateLimitRuleModel()
                {
                    RateLimit = result.RateLimit, RateLimitOptions = result.rateLimitOptions
                },
                                        TimeSpan.FromSeconds(_option.ClientRateLimitCacheTime), region);
                return(result);
            }
        }
        /// <summary>
        /// 校验客户端限流规则
        /// </summary>
        /// <param name="clientid">客户端ID</param>
        /// <param name="path">请求地址</param>
        /// <returns></returns>
        private async Task <(bool RateLimit, List <CzarClientRateLimitOptions> rateLimitOptions)> CheckClientRateLimitAsync(string clientid, string path)
        {
            var region      = CzarCacheRegion.RateLimitRuleModelRegion;
            var key         = clientid + path;
            var cacheResult = _rateLimitRuleCache.Get(key, region);

            if (cacheResult != null)
            {//提取缓存数据
                return(cacheResult.RateLimit, cacheResult.rateLimitOptions);
            }
            else
            {//重新获取限流策略
                var result = await _clientRateLimitRepository.CheckClientRateLimitAsync(clientid, path);

                _rateLimitRuleCache.Add(key, new RateLimitRuleModel()
                {
                    RateLimit = result.RateLimit, rateLimitOptions = result.rateLimitOptions
                }, TimeSpan.FromSeconds(_options.CzarCacheTime), region);
                return(result);
            }
        }
示例#3
0
        public async Task UpdateRateLimitRuleCache(string clientid, string path)
        {
            var region = CzarCacheRegion.RateLimitRuleModelRegion;
            var key    = clientid + path;

            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            var result = await _clientRateLimitRepository.CheckClientRateLimitAsync(clientid, path);

            var data = new RateLimitRuleModel()
            {
                RateLimit = result.RateLimit, rateLimitOptions = result.rateLimitOptions
            };

            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, data);              //加入redis缓存
                RedisHelper.Publish(key, data.ToJson()); //发布事件
            }
            else
            {
                _cache.Remove(key);
            }
        }