static IpRateLimit()
{
if (Setting.Configuration?.IpRateLimiting == null)
{
return;
}
Logger = Factory.Logger.Value;
Options = Setting.Configuration.IpRateLimiting;
Policies = Setting.Configuration.IpRateLimitPolicies;
IpParser = new ReversProxyIpParser(Options.RealIpHeader);
MemoryCache = Factory.MemoryCache.Value;
var rateLimitCounterStore = Factory.RateLimitCounterStore.Value;
var ipPolicyStore = new MemoryCacheIpPolicyStore(MemoryCache, Options, Policies);
Processor = new IpRateLimitProcessor(Options, rateLimitCounterStore, ipPolicyStore, IpParser);
Configurationed = true;
}
public IpRateLimitProcessor(
IpRateLimitOptions options,
ICacheManager cacheManager,
IRateLimitConfiguration config)
: base(cacheManager, options, new IpCounterKeyBuilder(), config)
{
_options = options;
}
public MemoryCacheIpPolicyStore(
IMemoryCache cache,
IpRateLimitOptions options = null,
IpRateLimitPolicies policies = null) : base(cache)
{
_options = options;
_policies = policies;
}
public RateLimitConfiguration(
IpRateLimitOptions ipOptions,
ClientRateLimitOptions clientOptions)
{
IpRateLimitOptions = ipOptions;
ClientRateLimitOptions = clientOptions;
RegisterResolvers();
}
public RedisIpPolicyStore(
ICache cache,
IOptions <MineIpRateLimitOptions> options = null,
IOptions <IpRateLimitPolicies> policies = null) : base(cache)
{
_options = options?.Value;
_policies = policies?.Value;
_cache = cache;
}
public IpPolicyStore(
ICacheManager cacheManager,
IOptions <IpRateLimitOptions> options = null,
IOptions <IpRateLimitPolicies> policies = null)
{
_cacheManager = cacheManager;
_options = options?.Value;
_policies = policies?.Value;
}
public IpRateLimitProcessor(
IpRateLimitOptions options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
IRateLimitConfiguration config)
: base(options, counterStore, new IpCounterKeyBuilder(options), config)
{
_options = options;
_policyStore = policyStore;
}
public CustomRateLimitConfiguration(IHttpContextAccessor httpContextAccessor, IClientPolicyStore clientPolicyStore, IOptions <IpRateLimitOptions> ipOptions, IOptions <ClientRateLimitOptions> clientOptions, IOptions <ClientRateLimitPolicies> clientPolicies)
{
IpRateLimitOptions = ipOptions?.Value;
ClientRateLimitOptions = clientOptions?.Value;
ClientRateLimitPolicies = clientPolicies?.Value;
HttpContextAccessor = httpContextAccessor;
ClientPolicyStore = clientPolicyStore;
ClientResolvers = new List <IClientResolveContributor>();
IpResolvers = new List <IIpResolveContributor>();
RegisterResolvers();
}
public CustomRateLimitingMiddleware(RequestDelegate next,
IProcessingStrategy processingStrategy,
IOptions <IpRateLimitOptions> options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
IRateLimitConfiguration config,
ILogger <IpRateLimitMiddleware> logger)
: base(next, processingStrategy, options, counterStore, policyStore, config, logger)
{
_rateLimitOptions = options.Value;
}
public CustomIpRateLimitMiddleware(
RequestDelegate next,
IOptions <IpRateLimitOptions> options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
ILogger <IpRateLimitMiddleware> logger,
IIpAddressParser ipParser = null
) : base(next, options, counterStore, policyStore, logger, ipParser)
{
_options = options.Value;
}
public IpRateLimitProcessor(IpRateLimitOptions options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
IIpAddressParser ipParser)
{
_options = options;
_counterStore = counterStore;
_policyStore = policyStore;
_ipParser = ipParser;
_core = new RateLimitCore(true, options, _counterStore);
}
public MemoryCacheIpPolicyStore(IMemoryCache memoryCache,
IpRateLimitOptions options = null,
IpRateLimitPolicies policies = null)
{
_memoryCache = memoryCache;
//save ip rules defined in appsettings in cache on startup
if (options != null && policies != null && policies.IpRules != null)
{
Set($"{options.IpPolicyPrefix}", policies);
}
}
public MyIPRateMiddleware(
RequestDelegate next,
IOptions <IpRateLimitOptions> options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
ILogger <IpRateLimitMiddleware> logger,
IIpAddressParser ipParser = null)
{
this._next = next;
this._options = options.Value;
this._logger = logger;
this._ipParser = ipParser != null ? ipParser : (IIpAddressParser) new ReversProxyIpParser(this._options.RealIpHeader);
this._processor = new IpRateLimitProcessor(this._options, counterStore, policyStore, this._ipParser);
}
/// <summary>
/// Get Client Ip using HttpContextAccessor
/// </summary>
/// <param name="settings"></param>
/// <param name="httpContext"></param>
/// <returns></returns>
public static string GetClientIP(IpRateLimitOptions settings, IHttpContextAccessor httpContext)
{
string ip = string.Empty;
if (string.IsNullOrWhiteSpace(settings.RealIpHeader))
{
ip = httpContext.HttpContext.Request.HttpContext.Connection.RemoteIpAddress.ToString();
}
else
{
ip = httpContext.HttpContext.Request.Headers.FirstOrDefault(x => x.Key == settings.RealIpHeader).Value;
}
return(ip);
}
public CustomIpRateLimitMiddleware(
IMemoryCache memoryCache,
IBlockIpService blockIpService,
RequestDelegate next,
IOptions<IpRateLimitOptions> options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
ILogger<IpRateLimitMiddleware> logger,
IIpAddressParser ipParser = null)
: base(next, options, counterStore, policyStore, logger, ipParser)
{
_memoryCache = memoryCache;
_blockIpService = blockIpService;
_options = options.Value;
_logger = logger;
}
public CustomIpRateLimitMiddleware(
IDistributedCache distributedCache,
IBlockIpService blockIpService,
RequestDelegate next,
IProcessingStrategy processingStrategy,
IRateLimitConfiguration rateLimitConfiguration,
IOptions <IpRateLimitOptions> options,
IIpPolicyStore policyStore,
ILogger <CustomIpRateLimitMiddleware> logger)
: base(next, processingStrategy, options, policyStore, rateLimitConfiguration, logger)
{
_distributedCache = distributedCache;
_blockIpService = blockIpService;
_options = options.Value;
_logger = logger;
}
public CustomIpRateLimitMiddleware(
IMemoryCache memoryCache,
IBlockIpService blockIpService,
RequestDelegate next,
IOptions <IpRateLimitOptions> options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
ILogger <IpRateLimitMiddleware> logger,
IIpAddressParser ipParser = null)
: base(next, options, counterStore, policyStore, logger, ipParser)
{
_memoryCache = memoryCache;
_blockIpService = blockIpService;
_options = options.Value;
_logger = logger;
}
private static void ConfigureIpRateLimitOptions(IpRateLimitOptions options)
{
options.EnableEndpointRateLimiting = false;
// exclude admin api and metrics from throtteling
options.EndpointWhitelist = new List <string>
{
"*:/api/admin",
"get:/metrics",
"*:/notifications",
};
options.IpWhitelist = clusterConfig.Api?.RateLimiting?.IpWhitelist?.ToList();
// default to whitelist localhost if whitelist absent
if (options.IpWhitelist == null || options.IpWhitelist.Count == 0)
{
options.IpWhitelist = new List <string>
{
IPAddress.Loopback.ToString(),
IPAddress.IPv6Loopback.ToString(),
IPUtils.IPv4LoopBackOnIPv6.ToString()
};
}
// limits
var rules = clusterConfig.Api?.RateLimiting?.Rules?.ToList();
if (rules == null || rules.Count == 0)
{
rules = new List <RateLimitRule>
{
new RateLimitRule
{
Endpoint = "*",
Period = "1s",
Limit = 5,
}
};
}
options.GeneralRules = rules;
logger.Info(() => $"API access limited to {(string.Join(", ", rules.Select(x => $"{x.Limit} requests per {x.Period}")))}, except from {string.Join(", ", options.IpWhitelist)}");
}
private static void SetupIpRateLimitOptions(IpRateLimitOptions options)
{
options.GeneralRules = new List <RateLimitRule>
{
new RateLimitRule
{
Endpoint = "*",
Limit = 1000,
Period = "5m"
},
new RateLimitRule
{
Endpoint = "*",
Limit = 200,
Period = "10s"
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="ThrottleMiddleware"/> class.
/// </summary>
/// <param name="next">The next.</param>
/// <param name="options">The options.</param>
/// <param name="counterStore">The counter store.</param>
/// <param name="policyStore">The policy store.</param>
/// <param name="config">The rate limit configuration.</param>
/// <param name="logger">The logger.</param>
/// <param name="configuration">The API configuration.</param>
/// <param name="serializer">The JSON serializer.</param>
/// <exception cref="ArgumentNullException">configuration</exception>
public ThrottleMiddleware(
RequestDelegate next,
IOptions <IpRateLimitOptions> options,
IRateLimitCounterStore counterStore,
IIpPolicyStore policyStore,
IRateLimitConfiguration config,
ILogger <IpRateLimitMiddleware> logger,
IApiConfiguration configuration,
IDefaultJsonSerializer serializer)
: base(next, options, counterStore, policyStore, config, logger)
{
Ensure.ArgumentNotNull(options, nameof(options));
if (options.Value == null)
{
throw new UnexpectedNullException("The options value is null.");
}
this.options = options.Value;
this.configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
public IpRateLimitController(IOptions <IpRateLimitOptions> optionsAccessor, IIpPolicyStore ipPolicyStore)
{
_options = optionsAccessor.Value;
_ipPolicyStore = ipPolicyStore;
}
public IpCounterKeyBuilder(IpRateLimitOptions options)
{
_options = options;
}
public ParametersManagerController(ParametersManager parametersManager, IOptions <IpRateLimitOptions> rateLimitOptions, IIpPolicyStore ipPolicyStore)
{
_parametersManager = parametersManager;
_rateLimitOptions = rateLimitOptions.Value;
_ipPolicyStore = ipPolicyStore;
}
public IpRateLimitHttpService(IIpRateLimitStorageProvider provider, IHttpContextAccessor httpContext, IOptions <IpRateLimitOptions> settings)
{
_provider = provider;
_httpContext = httpContext;
_settings = settings.Value;
}
public MemoryCacheProvider(IMemoryCache cache, IOptions <IpRateLimitOptions> settings)
{
_cache = cache;
this.settings = settings.Value;
}
