public T Get(string key, string region) { key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key); if (region == CzarCacheRegion.CzarClientRateLimitCounterRegion && _options.ClusterEnvironment) {//限流且开启了集群支持,默认从redis取 return(RedisHelper.Get <T>(key)); } var result = _cache.Get <T>(key); if (result == null && _options.ClusterEnvironment) { result = RedisHelper.Get <T>(key); if (result != null) { if (typeof(T) == typeof(CachedResponse)) {//查看redis过期时间 var second = RedisHelper.Ttl(key); if (second > 0) { _cache.Set(key, result, TimeSpan.FromSeconds(second)); } } else { _cache.Set(key, result, TimeSpan.FromSeconds(_options.CzarCacheTime)); } } } return(result); }
public void Add(string key, T value, TimeSpan ttl, string region) { key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key); if (_options.ClusterEnvironment) { var msg = value.ToJson(); if (typeof(T) == typeof(CachedResponse)) { //带过期时间的缓存 _cache.Set(key, value, ttl); //添加本地缓存 RedisHelper.Set(key, msg, (int)ttl.TotalSeconds); //加入redis缓存 RedisHelper.Publish(key, msg); //发布 } else if (typeof(T) == typeof(CzarClientRateLimitCounter?)) {//限流缓存,直接使用redis RedisHelper.Set(key, value, (int)ttl.TotalSeconds); } else { //正常缓存,发布 _cache.Set(key, value, ttl); //添加本地缓存 RedisHelper.Set(key, msg); //加入redis缓存 RedisHelper.Publish(key, msg); //发布 } } else { _cache.Set(key, value, ttl); //添加本地缓存 } }
public async Task DeleteResponseCache(string region, string downurl) { var key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, downurl); if (_options.ClusterEnvironment) { await RedisHelper.DelAsync(key); RedisHelper.Publish(key, "");//发布时间 } else { _cache.Remove(key); } }
public async Task UpdateRpcCache(string UpUrl) { var region = CzarCacheRegion.RemoteInvokeMessageRegion; var key = UpUrl; key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key); var result = await _rpcRepository.GetRemoteMethodAsync(UpUrl); if (_options.ClusterEnvironment) { RedisHelper.Set(key, result); //加入redis缓存 RedisHelper.Publish(key, result.ToJson()); //发布事件 } else { _cache.Remove(key); } }
/// <summary> /// 校验完整的限流规则 /// </summary> /// <param name="rateLimitOptions">限流配置</param> /// <returns></returns> private bool CheckRateLimitResult(List <CzarClientRateLimitOptions> rateLimitOptions) { bool result = true; if (rateLimitOptions != null && rateLimitOptions.Count > 0) {//校验策略 foreach (var op in rateLimitOptions) { CzarClientRateLimitCounter counter = new CzarClientRateLimitCounter(DateTime.UtcNow, 1); //分别对每个策略校验 var enablePrefix = CzarCacheRegion.CzarClientRateLimitCounterRegion; var key = CzarOcelotHelper.ComputeCounterKey(enablePrefix, op.ClientId, op.Period, op.RateLimitPath); var periodTimestamp = CzarOcelotHelper.ConvertToSecond(op.Period); lock (_processLocker) { var rateLimitCounter = _clientRateLimitCounter.Get(key, enablePrefix); if (rateLimitCounter.HasValue) {//提取当前的计数情况 // 请求次数增长 var totalRequests = rateLimitCounter.Value.TotalRequests + 1; // 深拷贝 counter = new CzarClientRateLimitCounter(rateLimitCounter.Value.Timestamp, totalRequests); } else {//写入限流策略 _clientRateLimitCounter.Add(key, counter, TimeSpan.FromSeconds(periodTimestamp), enablePrefix); } } if (counter.TotalRequests > op.Limit) {//更新请求记录,并标记为失败 result = false; } if (counter.TotalRequests > 1 && counter.TotalRequests <= op.Limit) {//更新缓存配置信息 //获取限流剩余时间 var cur = (int)(counter.Timestamp.AddSeconds(periodTimestamp) - DateTime.UtcNow).TotalSeconds; _clientRateLimitCounter.Add(key, counter, TimeSpan.FromSeconds(cur), enablePrefix); } } } return(result); }
public async Task UpdateInternalConfigurationCache() { var key = CzarCacheRegion.InternalConfigurationRegion; key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, "", key); var fileconfig = await _fileConfigurationRepository.Get(); var internalConfig = await _internalConfigurationCreator.Create(fileconfig.Data); var config = (InternalConfiguration)internalConfig.Data; if (_options.ClusterEnvironment) { RedisHelper.Set(key, config); //加入redis缓存 RedisHelper.Publish(key, config.ToJson()); //发布事件 } else { _cache.Remove(key); } }
/// <summary> /// 校验当前的请求地址客户端是否有权限访问 /// </summary> /// <param name="clientid">客户端ID</param> /// <param name="path">请求地址</param> /// <returns></returns> public async Task <bool> CheckClientAuthenticationAsync(string clientid, string path) { var enablePrefix = CzarCacheRegion.AuthenticationRegion; var key = CzarOcelotHelper.ComputeCounterKey(enablePrefix, clientid, "", path); var cacheResult = _ocelotCache.Get(key, enablePrefix); if (cacheResult != null) {//提取缓存数据 return(cacheResult.Role); } else {//重新获取认证信息 var result = await _clientAuthenticationRepository.ClientAuthenticationAsync(clientid, path); //添加到缓存里 _ocelotCache.Add(key, new ClientRoleModel() { CacheTime = DateTime.Now, Role = result }, TimeSpan.FromMinutes(_options.CzarCacheTime), enablePrefix); return(result); } }
public async Task UpdateClientRuleCache(string clientid, string path) { var region = CzarCacheRegion.AuthenticationRegion; var key = CzarOcelotHelper.ComputeCounterKey(region, clientid, "", path); key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key); var result = await _clientAuthenticationRepository.ClientAuthenticationAsync(clientid, path); var data = new ClientRoleModel() { CacheTime = DateTime.Now, Role = result }; if (_options.ClusterEnvironment) { RedisHelper.Set(key, data); //加入redis缓存 RedisHelper.Publish(key, data.ToJson()); //发布事件 } else { _cache.Remove(key); } }
public async Task UpdateClientReRouteWhiteListCache(string clientid, string path) { var region = CzarCacheRegion.ClientReRouteWhiteListRegion; var key = clientid + path; key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key); var result = await _clientRateLimitRepository.CheckClientReRouteWhiteListAsync(clientid, path); var data = new ClientRoleModel() { CacheTime = DateTime.Now, Role = result }; if (_options.ClusterEnvironment) { RedisHelper.Set(key, data); //加入redis缓存 RedisHelper.Publish(key, data.ToJson()); //发布事件 } else { _cache.Remove(key); } }
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); } }