Exemple #1
0
        internal static ISettings GetSettings(IConfiguration configuration)
        {
            string sourceRoot          = configuration.GetValue <string>("SourceRoot");
            string destinationRootUrl  = configuration.GetValue <string>("DestinationRootUrl");
            string destinationRootPath = configuration.GetValue <string>("DestinationRootPath");

            ILocation destinationRoot = new Location(new Uri(destinationRootUrl), destinationRootPath);

            IConfigurationSection rateLimiterConfig   = configuration.GetSection("RateLimiter");
            IRateLimiterSettings  rateLimiterSettings = new RateLimiterSettings
            {
                Enabled                 = rateLimiterConfig.GetValue("Enabled", false),
                TimeWindowInMinutes     = rateLimiterConfig.GetValue("TimeWindowInMinutes", 10),
                MaxRequestsInTimeWindow = rateLimiterConfig.GetValue("MaxRequestsInTimeWindow", 100),
                MaxBytesInTimeWindow    = rateLimiterConfig.GetValue("MaxBytesInTimeWindow", 1024 * 1024 * 50),
                Whitelist               = rateLimiterConfig.GetSection("Whitelist").GetChildren().ToList().Select(x => x.Value).ToArray(),
                Blacklist               = rateLimiterConfig.GetSection("Blacklist").GetChildren().ToList().Select(x => x.Value).ToArray()
            };

            IConfigurationSection loggerConfig   = configuration.GetSection("Logger");
            ILoggerSettings       loggerSettings = new LoggerSettings
            {
                WriteInfo     = loggerConfig.GetValue("WriteInfo", false),
                WriteWarnings = loggerConfig.GetValue("WriteWarnings", false),
                WriteErrors   = loggerConfig.GetValue("WriteErrors", false),
                ToConsole     = loggerConfig.GetValue("ToConsole", false),
                ToFile        = loggerConfig.GetValue("ToFile", false),
                Directory     = loggerConfig.GetValue("Directory", string.Empty)
            };

            IConfigurationSection gifConfig   = configuration.GetSection("GifSettings");
            IGifSettings          gifSettings = new GifSettings
            {
                PostProcessorEnabled = gifConfig.GetValue("PostProcessorEnabled", false),
                PostProcessorCommand = gifConfig.GetValue("PostProcessorCommand", string.Empty)
            };

            IConfigurationSection jpegConfig   = configuration.GetSection("JpegSettings");
            IJpegSettings         jpegSettings = new JpegSettings
            {
                Quality = jpegConfig.GetValue("Quality", 75),
                PostProcessorEnabled = jpegConfig.GetValue("PostProcessorEnabled", false),
                PostProcessorCommand = jpegConfig.GetValue("PostProcessorCommand", string.Empty)
            };

            IConfigurationSection pngConfig   = configuration.GetSection("PngSettings");
            IPngSettings          pngSettings = new PngSettings
            {
                CompressionLevel     = pngConfig.GetValue("CompressionLevel", 6),
                PostProcessorEnabled = pngConfig.GetValue("PostProcessorEnabled", false),
                PostProcessorCommand = pngConfig.GetValue("PostProcessorCommand", string.Empty)
            };

            Settings settings = new Settings(sourceRoot, destinationRoot, rateLimiterSettings, loggerSettings, gifSettings, jpegSettings, pngSettings);

            return(settings);
        }
Exemple #2
0
        public static IApplicationBuilder UseRateLimiter(this IApplicationBuilder builder)
        {
            var config = builder.ApplicationServices.GetService <IConfiguration>();
            var rateLimiterSettings = new RateLimiterSettings();

            config.GetSection("RateLimiterSettings").Bind(rateLimiterSettings);

            var cache = builder.ApplicationServices.GetService <IDistributedCache>();

            return(builder.UseMiddleware <RateLimiterMiddleware>(cache, rateLimiterSettings));
        }
Exemple #3
0
        private IRateLimiterSettings GetRateLimiterSettings(bool enabled)
        {
            RateLimiterSettings rateLimiterSettings = new RateLimiterSettings
            {
                Enabled                 = enabled,
                TimeWindowInMinutes     = 1,
                MaxRequestsInTimeWindow = 2,
                MaxBytesInTimeWindow    = 1000,
                Whitelist               = new string[] { "000.000.000.000", "111.111.111.111", "222.222.222.222" },
                Blacklist               = new string[] { "777.777.777.777", "888.888.888.888", "999.999.999.999" }
            };

            return(rateLimiterSettings);
        }
Exemple #4
0
        async static Task Main(string[] args)
        {
            Debug.WriteLine($"[~] {System.AppDomain.CurrentDomain.FriendlyName} - START");

            var region       = Region.EUROPE;
            var key          = "RGAPI-a6dbecf6-e05b-4ca4-aa82-0eae6e5b666a";
            var databasePath = @"P:\C#\cache.db";

            var client = new Client(region, key);

            client.SetCache(databasePath);

            var rateLimiterSettings = new RateLimiterSettings();

            rateLimiterSettings.AddRateLimit(20, TimeSpan.FromSeconds(1));
            rateLimiterSettings.AddRateLimit(100, TimeSpan.FromMinutes(2));

            rateLimiterSettings.EnableRateLimiter(client);

            Debug.WriteLine($"[I] Current region: {region}");

            client.CompletedRequest += (object sender, EventArgs e) => {
                var clientRequest = e as ClientRequestEventArgs;
                Debug.WriteLine($"[CompletedRequest] {clientRequest.ResponseContent}");
            };

            client.ErrorRequest += (object sender, EventArgs e) =>
            {
                var clientRequestError = e as ClientRequestErrorEventArgs;
                Debug.WriteLine($"[E] ({clientRequestError.StatusCode}) {clientRequestError.Message}");
            };

            var contentsEndpoint = new ContentsEndpoint()
            {
                locale = Locale.ES_ES
            };

            var contentResponse = await client.GetAsync <ContentDto>(contentsEndpoint);

            Debug.WriteLine($"First gamemode: {contentResponse.gameModes.First().name}");

            Debug.WriteLine($"[~] {System.AppDomain.CurrentDomain.FriendlyName} - END");
        }
Exemple #5
0
 public RateLimiterMiddleware(RequestDelegate next, IDistributedCache cache, RateLimiterSettings settings)
 {
     _next    = next;
     _cache   = cache;
     Settings = settings;
 }
Exemple #6
0
        public void TestFullConfiguration()
        {
            string   sourceRoot      = "source/root";
            Location destinationRoot = new Location(new Uri("http://site.com/images"), "/var/www/site.com/images");

            RateLimiterSettings rateLimiterSettings = new RateLimiterSettings();

            rateLimiterSettings.Enabled                 = true;
            rateLimiterSettings.TimeWindowInMinutes     = 42;
            rateLimiterSettings.MaxRequestsInTimeWindow = 1337;
            rateLimiterSettings.MaxBytesInTimeWindow    = 1000000;
            rateLimiterSettings.Whitelist               = new string[] { "1.3.3.7" };
            rateLimiterSettings.Blacklist               = new string[] { "6.6.6.666", "666.666.666.666" };

            LoggerSettings loggerSettings = new LoggerSettings();

            loggerSettings.WriteInfo     = true;
            loggerSettings.WriteWarnings = true;
            loggerSettings.WriteErrors   = true;
            loggerSettings.ToConsole     = true;
            loggerSettings.ToFile        = true;
            loggerSettings.Directory     = "path/to/log";

            GifSettings gifSettings = new GifSettings();

            gifSettings.PostProcessorEnabled = true;
            gifSettings.PostProcessorCommand = "path/to/gifsicle some gifsicle args";

            JpegSettings jpegSettings = new JpegSettings();

            jpegSettings.Quality = 50;
            jpegSettings.PostProcessorEnabled = true;
            jpegSettings.PostProcessorCommand = "path/to/jpegtran some jpegtran args";

            PngSettings pngSettings = new PngSettings();

            pngSettings.CompressionLevel     = 3;
            pngSettings.PostProcessorEnabled = true;
            pngSettings.PostProcessorCommand = "path/to/optipng some optipng args";

            Settings settings = new Settings(sourceRoot, destinationRoot, rateLimiterSettings, loggerSettings, gifSettings, jpegSettings, pngSettings);

            Assert.True(settings.SourceRoot == sourceRoot);
            Assert.True(settings.DestinationRoot.AbsoluteUrl == destinationRoot.AbsoluteUrl);
            Assert.True(settings.DestinationRoot.AbsolutePath == destinationRoot.AbsolutePath);

            Assert.True(settings.RateLimiterSettings.Enabled == true);
            Assert.True(settings.RateLimiterSettings.TimeWindowInMinutes == 42);
            Assert.True(settings.RateLimiterSettings.MaxRequestsInTimeWindow == 1337);
            Assert.True(settings.RateLimiterSettings.MaxBytesInTimeWindow == 1000000);
            Assert.True(settings.RateLimiterSettings.Whitelist.Length == 1 && settings.RateLimiterSettings.Whitelist[0] == "1.3.3.7");
            Assert.True(settings.RateLimiterSettings.Blacklist.Length == 2 && settings.RateLimiterSettings.Blacklist[0] == "6.6.6.666" && settings.RateLimiterSettings.Blacklist[1] == "666.666.666.666");

            Assert.True(settings.LoggerSettings.WriteInfo == true);
            Assert.True(settings.LoggerSettings.WriteWarnings == true);
            Assert.True(settings.LoggerSettings.WriteErrors == true);
            Assert.True(settings.LoggerSettings.ToConsole == true);
            Assert.True(settings.LoggerSettings.ToFile == true);
            Assert.True(settings.LoggerSettings.Directory == "path/to/log");

            Assert.True(settings.GifSettings.PostProcessorEnabled);
            Assert.True(settings.GifSettings.PostProcessorCommand == "path/to/gifsicle some gifsicle args");

            Assert.True(settings.JpegSettings.Quality == 50);
            Assert.True(settings.JpegSettings.PostProcessorEnabled);
            Assert.True(settings.JpegSettings.PostProcessorCommand == "path/to/jpegtran some jpegtran args");

            Assert.True(settings.PngSettings.CompressionLevel == 3);
            Assert.True(settings.PngSettings.PostProcessorEnabled);
            Assert.True(settings.PngSettings.PostProcessorCommand == "path/to/optipng some optipng args");
        }