public RedisInternalConfigurationRepository(CzarOcelotConfiguration options, IFileConfigurationRepository fileConfigurationRepository, IInternalConfigurationCreator internalConfigurationCreator, IOcelotCache <InternalConfiguration> ocelotCache) { _fileConfigurationRepository = fileConfigurationRepository; _internalConfigurationCreator = internalConfigurationCreator; _options = options; _ocelotCache = ocelotCache; }
public CzarClientRateLimitProcessor(CzarOcelotConfiguration options, IClientRateLimitRepository clientRateLimitRepository, IOcelotCache <CzarClientRateLimitCounter?> clientRateLimitCounter, IOcelotCache <ClientRoleModel> ocelotCache, IOcelotCache <RateLimitRuleModel> rateLimitRuleCache) { _options = options; _clientRateLimitRepository = clientRateLimitRepository; _clientRateLimitCounter = clientRateLimitCounter; _ocelotCache = ocelotCache; _rateLimitRuleCache = rateLimitRuleCache; }
public CzarClientRateLimitMiddleware(OcelotRequestDelegate next, IOcelotLoggerFactory loggerFactory, IClientRateLimitProcessor clientRateLimitProcessor, CzarOcelotConfiguration options) : base(loggerFactory.CreateLogger <CzarClientRateLimitMiddleware>()) { _next = next; _clientRateLimitProcessor = clientRateLimitProcessor; _options = options; }
public CzarAuthenticationMiddleware(OcelotRequestDelegate next, IOcelotLoggerFactory loggerFactory, ICzarAuthenticationProcessor ahphAuthenticationProcessor, CzarOcelotConfiguration options) : base(loggerFactory.CreateLogger <CzarAuthenticationMiddleware>()) { _next = next; _ahphAuthenticationProcessor = ahphAuthenticationProcessor; _options = options; }
public CzarCacheController(IClientAuthenticationRepository clientAuthenticationRepository, CzarOcelotConfiguration options, IFileConfigurationRepository fileConfigurationRepository, IInternalConfigurationCreator internalConfigurationCreator, IClientRateLimitRepository clientRateLimitRepository, IRpcRepository rpcRepository, IMemoryCache cache) { _clientAuthenticationRepository = clientAuthenticationRepository; _options = options; _fileConfigurationRepository = fileConfigurationRepository; _internalConfigurationCreator = internalConfigurationCreator; _clientRateLimitRepository = clientRateLimitRepository; _rpcRepository = rpcRepository; _cache = cache; }
public InRedisCache(CzarOcelotConfiguration options) { _options = options; CSRedis.CSRedisClient csredis; if (options.RedisConnectionStrings.Count == 1) { //普通模式 csredis = new CSRedis.CSRedisClient(options.RedisConnectionStrings[0]); } else { //集群模式 //实现思路:根据key.GetHashCode() % 节点总数量,确定连向的节点 //也可以自定义规则(第一个参数设置) csredis = new CSRedis.CSRedisClient(null, options.RedisConnectionStrings.ToArray()); } //初始化 RedisHelper RedisHelper.Initialization(csredis); }
public RedisInternalConfigurationRepository(CzarOcelotConfiguration options, IFileConfigurationRepository fileConfigurationRepository, IInternalConfigurationCreator internalConfigurationCreator) { _fileConfigurationRepository = fileConfigurationRepository; _internalConfigurationCreator = internalConfigurationCreator; _options = options; CSRedis.CSRedisClient csredis; if (options.RedisConnectionStrings.Count == 1) { //普通模式 csredis = new CSRedis.CSRedisClient(options.RedisConnectionStrings[0]); } else { //集群模式 //实现思路:根据key.GetHashCode() % 节点总数量,确定连向的节点 //也可以自定义规则(第一个参数设置) csredis = new CSRedis.CSRedisClient(null, options.RedisConnectionStrings.ToArray()); } //初始化 RedisHelper RedisHelper.Initialization(csredis); }
/// <summary> /// 添加默认的注入方式,所有需要传入的参数都是用默认值 /// </summary> /// <param name="builder"></param> /// <returns></returns> public static IOcelotBuilder AddCzarOcelot(this IOcelotBuilder builder, Action <CzarOcelotConfiguration> option) { //builder.Services.Configure(option); ////配置信息 //builder.Services.AddSingleton( // resolver => resolver.GetRequiredService<IOptions<CzarOcelotConfiguration>>().Value); var options = new CzarOcelotConfiguration(); builder.Services.AddSingleton(options); option?.Invoke(options); //配置文件仓储注入 builder.Services.AddSingleton <IFileConfigurationRepository, SqlServerFileConfigurationRepository>(); builder.Services.AddSingleton <IClientAuthenticationRepository, SqlServerClientAuthenticationRepository>(); builder.Services.AddSingleton <IClientRateLimitRepository, SqlServerClientRateLimitRepository>(); builder.Services.AddSingleton <IRpcRepository, SqlServerRpcRepository>(); //注册后端服务 builder.Services.AddHostedService <DbConfigurationPoller>(); //使用Redis重写缓存 builder.Services.AddSingleton <IOcelotCache <FileConfiguration>, InRedisCache <FileConfiguration> >(); builder.Services.AddSingleton <IOcelotCache <CachedResponse>, InRedisCache <CachedResponse> >(); builder.Services.AddSingleton <IInternalConfigurationRepository, RedisInternalConfigurationRepository>(); builder.Services.AddSingleton <IOcelotCache <ClientRoleModel>, InRedisCache <ClientRoleModel> >(); builder.Services.AddSingleton <IOcelotCache <RateLimitRuleModel>, InRedisCache <RateLimitRuleModel> >(); builder.Services.AddSingleton <IOcelotCache <RemoteInvokeMessage>, InRedisCache <RemoteInvokeMessage> >(); builder.Services.AddSingleton <IOcelotCache <CzarClientRateLimitCounter?>, InRedisCache <CzarClientRateLimitCounter?> >(); //注入授权 builder.Services.AddSingleton <ICzarAuthenticationProcessor, CzarAuthenticationProcessor>(); //注入限流实现 builder.Services.AddSingleton <IClientRateLimitProcessor, CzarClientRateLimitProcessor>(); //重写错误状态码 builder.Services.AddSingleton <IErrorsToHttpStatusCodeMapper, CzarErrorsToHttpStatusCodeMapper>(); //http输出转换类 builder.Services.AddSingleton <IHttpResponder, CzarHttpContextResponder>(); //Rpc应用 builder.Services.AddSingleton <ICzarRpcProcessor, CzarRpcProcessor>(); return(builder); }
public CzarMemoryCache(CzarOcelotConfiguration options, IMemoryCache cache) { _options = options; _cache = cache; }
/// <summary> /// 添加默认的注入方式,所有需要传入的参数都是用默认值 /// </summary> /// <param name="builder"></param> /// <returns></returns> public static IOcelotBuilder AddCzarOcelot(this IServiceCollection builder, Action <CzarOcelotConfiguration> option) { var options = new CzarOcelotConfiguration(); builder.AddSingleton(options); option?.Invoke(options); //配置文件仓储注入 builder.AddSingleton <IFileConfigurationRepository, SqlServerFileConfigurationRepository>(); builder.AddSingleton <IClientAuthenticationRepository, SqlServerClientAuthenticationRepository>(); builder.AddSingleton <IClientRateLimitRepository, SqlServerClientRateLimitRepository>(); //注册后端服务 builder.AddHostedService <DbConfigurationPoller>(); builder.AddMemoryCache(); //添加本地缓存 #region 启动Redis缓存,并支持普通模式 官方集群模式 哨兵模式 分区模式 if (options.ClusterEnvironment) { //默认使用普通模式 var csredis = new CSRedis.CSRedisClient(options.RedisConnectionString); switch (options.RedisStoreMode) { case RedisStoreMode.Partition: var NodesIndex = options.RedisSentinelOrPartitionConStr; Func <string, string> nodeRule = null; csredis = new CSRedis.CSRedisClient(nodeRule, options.RedisSentinelOrPartitionConStr); break; case RedisStoreMode.Sentinel: csredis = new CSRedis.CSRedisClient(options.RedisConnectionString, options.RedisSentinelOrPartitionConStr); break; } //初始化 RedisHelper RedisHelper.Initialization(csredis); } #endregion builder.AddSingleton <IOcelotCache <FileConfiguration>, CzarMemoryCache <FileConfiguration> >(); builder.AddSingleton <IOcelotCache <InternalConfiguration>, CzarMemoryCache <InternalConfiguration> >(); builder.AddSingleton <IOcelotCache <CachedResponse>, CzarMemoryCache <CachedResponse> >(); builder.AddSingleton <IInternalConfigurationRepository, RedisInternalConfigurationRepository>(); builder.AddSingleton <IOcelotCache <ClientRoleModel>, CzarMemoryCache <ClientRoleModel> >(); builder.AddSingleton <IOcelotCache <RateLimitRuleModel>, CzarMemoryCache <RateLimitRuleModel> >(); builder.AddSingleton <IOcelotCache <RemoteInvokeMessage>, CzarMemoryCache <RemoteInvokeMessage> >(); builder.AddSingleton <IOcelotCache <CzarClientRateLimitCounter?>, CzarMemoryCache <CzarClientRateLimitCounter?> >(); //注入授权 builder.AddSingleton <ICzarAuthenticationProcessor, CzarAuthenticationProcessor>(); //注入限流实现 builder.AddSingleton <IClientRateLimitProcessor, CzarClientRateLimitProcessor>(); //重写错误状态码 builder.AddSingleton <IErrorsToHttpStatusCodeMapper, CzarErrorsToHttpStatusCodeMapper>(); //http输出转换类 builder.AddSingleton <IHttpResponder, CzarHttpContextResponder>(); var service = builder.First(x => x.ServiceType == typeof(IConfiguration)); var configuration = (IConfiguration)service.ImplementationInstance; //Rpc应用 builder.AddSingleton <ICzarRpcProcessor, CzarRpcProcessor>(); builder.AddSingleton <IRpcRepository, SqlServerRpcRepository>(); builder.AddLibuvTcpClient(configuration); return(new OcelotBuilder(builder, configuration)); }
public CzarRpcProcessor(IRpcRepository rpcRepository, CzarOcelotConfiguration options, IOcelotCache <RemoteInvokeMessage> ocelotCache) { _rpcRepository = rpcRepository; _options = options; _ocelotCache = ocelotCache; }
public CzarAuthenticationProcessor(IClientAuthenticationRepository clientAuthenticationRepository, CzarOcelotConfiguration options, IOcelotCache <ClientRoleModel> ocelotCache) { _clientAuthenticationRepository = clientAuthenticationRepository; _options = options; _ocelotCache = ocelotCache; }
public MySqlClientRateLimitRepository(CzarOcelotConfiguration option) { _option = option; }
public SqlServerFileConfigurationRepository(CzarOcelotConfiguration option) { _option = option; }
public MySqlFileConfigurationRepository(CzarOcelotConfiguration option) { _option = option; }
public MySqlClientAuthenticationRepository(CzarOcelotConfiguration option) { _option = option; }