public void TestConnectivity() { var redisStore = new RedisStore(); HttpResponseMessage responseMessage = null; Console.WriteLine(redisStore.TryGetValue(new CacheKey("http://google.com", new string[0]), out responseMessage)); }
private async Task <bool> HasInvalidStatusCode( LastChangedRecord record, RedisStore redisStore, int responseStatusCode, string requestUrl, HttpResponseMessage response) { if (_validStatusCodes.Contains(responseStatusCode)) { return(false); } _logger.LogWarning( "Backend call to {RequestUrl} ({AcceptType}) returned statuscode {StatusCode} which was invalid.", requestUrl, record.AcceptType, response.StatusCode); record.ErrorCount++; record.LastError = DateTimeOffset.UtcNow; record.LastErrorMessage = $"Backend call to {requestUrl} ({record.AcceptType}) returned statuscode {response.StatusCode} which was invalid."; if (record.ErrorCount >= _maxErrorCount) { _logger.LogInformation( "{CacheKey} reached {MaxErrorCount} errors, purging from cache.", record.CacheKey.ToLowerInvariant(), record.ErrorCount); await redisStore.DeleteKeyAsync(record.CacheKey.ToLowerInvariant()); } return(true); }
static void Main() { IDatabase db = RedisStore.getInstance().RedisCacheTable; var sub = db.Multiplexer.GetSubscriber(); sub.Subscribe(COUNTER_HINTS_CHANNEL, delegate { // process all messages in queue string msg = db.ListRightPop(COUNTER_QUEUE_NAME); while (msg != null) { UserData userData = JsonConvert.DeserializeObject <UserData>(msg); Console.WriteLine("Region: " + userData.region + " message: " + msg); int countGlasn = Regex.Matches(userData.message, @"[aiueoy]", RegexOptions.IgnoreCase).Count; int countSoglasn = Regex.Matches(userData.message, @"[bcdfghjklmnpqrstvwxz]", RegexOptions.IgnoreCase).Count; string message = getStringifyUserDataCounter(userData, countGlasn, countSoglasn); Console.WriteLine("Queue value: " + message); SendMessage(message, db); msg = db.ListRightPop(COUNTER_QUEUE_NAME); } }); Console.WriteLine("Observable subscribe vowel cons counter is ready. For exit press Enter."); Console.ReadLine(); }
public async Task OneTimeSetUp() { //_server.KillAll(); await _server.Start(); _multiplexer = ConnectionMultiplexer.Connect(ConfigurationOptions.Parse(RedisConnectionOptions)); _connection = new RedisTestDatabaseConnector(_multiplexer); _cacheType1 = new RedisStore <TestCompany>( new RedisTestDatabaseConnector(_multiplexer), new DefaultJsonSerializer(), new CollectionSettings <TestCompany> { MasterKeyExtractor = new TestCompanyKeyExtractor() } ); _cacheType2 = new RedisStore <TestPerson>( new RedisTestDatabaseConnector(_multiplexer), new DefaultJsonSerializer(), new CollectionSettings <TestPerson> { MasterKeyExtractor = new TestPersonKeyExtractor() }); _cacheType1WithExpiry = new RedisStore <TestCompany>( new RedisTestDatabaseConnector(_multiplexer), new DefaultJsonSerializer(), new CollectionSettings <TestCompany> { MasterKeyExtractor = new TestCompanyKeyExtractor(), Expiry = TimeSpan.FromSeconds(1) }); _database = new RedisDatabaseManager(_connection); }
public void TestConnectivity() { var redisStore = new RedisStore(ConnectionString); HttpResponseMessage responseMessage = null; Console.WriteLine(redisStore.GetValueAsync(new CacheKey("http://google.com", new string[0])).Result); }
public void AccessingLocalRedis100TimesLessThanASecond() { var c = new RedisStore(ConnectionString); var sw = Stopwatch.StartNew(); for (int i = 0; i < 100; i++) { var buffer = new byte[_r.Next(4 * 1024, 64 * 1024)]; _r.NextBytes(buffer); var key = new CacheKey(UrlStem + Guid.NewGuid().ToString(), new string[0]); var task = c.AddOrUpdateAsync(key, new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(buffer) }); task.GetAwaiter().GetResult(); var r = c.GetValueAsync(key).GetAwaiter().GetResult(); } if (sw.ElapsedMilliseconds > 1000) { throw new Exception("Took more than 1000 ms"); } }
static void Main() { RedisStore instance = RedisStore.getInstance(); IDatabase db = instance.RedisCacheTable; var sub = db.Multiplexer.GetSubscriber(); sub.Subscribe(RATE_HINTS_CHANNEL, delegate { // process all messages in queue string msg = db.ListRightPop(RATE_QUEUE_NAME); while (msg != null) { Console.WriteLine(msg); UserDataCounter userDataCounter = JsonConvert.DeserializeObject <UserDataCounter>(msg); double relation = userDataCounter.countSoglasn == 0 ? 0 : (double)userDataCounter.countGlasn / userDataCounter.countSoglasn; string message = GetStringifyUserDataRater(userDataCounter, relation); var idDb = (int)db.StringGet($"RANK_{userDataCounter.id}"); instance.RedisCache(idDb).StringSet($"RANK_{userDataCounter.id}", message); msg = db.ListRightPop(RATE_QUEUE_NAME); Console.WriteLine(GetStringifyTextStatisticConsRater(userDataCounter.id, relation)); sub.Publish(EVENTS, GetStringifyTextStatisticConsRater(userDataCounter.id, relation)); } }); Console.WriteLine("Observable subscribe vowel cons rater is ready. For exit press Enter."); Console.ReadLine(); }
public RedisBus(IConfiguration configuration, IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; var redisStore = new RedisStore(configuration); _redisDatabase = redisStore.RedisCache; }
public async Task MainAsync() { // You should dispose a service provider created using ASP.NET // when you are finished using it, at the end of your app's lifetime. // If you use another dependency injection framework, you should inspect // its documentation for the best way to do this. using (var services = ConfigureServices()) { var client = services.GetRequiredService <DiscordSocketClient>(); client.Log += LogAsync; services.GetRequiredService <CommandService>().Log += LogAsync; // Tokens should be considered secret data and never hard-coded. // We can read from the environment variable to avoid hardcoding. await client.LoginAsync(TokenType.Bot, RedisStore.GetSecret("KK2_BOT")); await client.StartAsync(); // Here we initialize the logic required to register our commands. await services.GetRequiredService <CommandHandlingService>().InitializeAsync(); await Task.Delay(Timeout.Infinite); } }
public DeviceHubService(ILogger <DeviceHubService> logger, IDeviceHistoryRepository deviceHistoryRepository, IDeviceService deviceService, IHubContext <WebHubService> webHubContext, RedisStore rediscache, IBackgroundTaskQueue queue, BadDisconnectSocketService badDisconnectSocketService, IMemoryCache memoryCache, INotificationSender notificationSenderExtention) { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _deviceHistoryRepository = deviceHistoryRepository ?? throw new ArgumentNullException(nameof(deviceHistoryRepository)); _deviceService = deviceService ?? throw new ArgumentNullException(nameof(deviceService)); _webHubContext = webHubContext ?? throw new ArgumentNullException(nameof(webHubContext)); _rediscache = rediscache.RedisCache ?? throw new ArgumentNullException(nameof(rediscache)); Queue = queue ?? throw new ArgumentNullException(nameof(queue)); _notificationSenderExtention = notificationSenderExtention ?? throw new ArgumentNullException(nameof(notificationSenderExtention)); _badDisconnectSocketService = badDisconnectSocketService ?? throw new ArgumentNullException(nameof(badDisconnectSocketService)); _memoryCache = memoryCache ?? throw new ArgumentNullException(nameof(memoryCache)); }
public NotificationSenderTests(BaseTest baseTest) { _baseTest = baseTest ?? throw new ArgumentNullException(nameof(baseTest)); var loggerMock = new Mock <ILogger <NotificationSender> >(); cache = _baseTest.redisStore; _notificationSender = new NotificationSender(_baseTest._notificationSenderExtentionOptions, cache, loggerMock.Object); }
public GivenABatchWasAlreadyStarted() { _sut = new RedisStore( RedisFixture.MockConnectionMultiplexer(RedisFixture.MockRedisBatch().Object), ETagFixture.MockETagGenerator()); _sut.CreateBatch(); }
public MeteoritesController(IHttpClientFactory clientFactory, Meteorite.MeteoriteClient meteoriteClient, TracerFactory tracerFactory, RedisStore redisStore, ILogger <WeatherForecastController> logger) { ClientFactory = clientFactory; TracerFactory = tracerFactory; RedisStore = redisStore; Logger = logger; MeteoriteClient = meteoriteClient; }
public MeteoriteServiceImpl(RedisStore redisStore, MessageBus messageBus, IHttpClientFactory clientFactory, TracerFactory tracerFactory, IConfiguration configuration, ILogger <MeteoriteServiceImpl> logger) { _redisStore = redisStore; _messageBus = messageBus; _clientFactory = clientFactory; _tracerFactory = tracerFactory; _configuration = configuration; _logger = logger; }
public void Redis_cache_empty_remove() { //Arrange var cache = new RedisStore(REDIS_LOCALHOST); //Act cache.Remove(string.Empty); //Assert Assert.NotNull(cache); }
public static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("Not enough arguments. Must set count limit words"); return; } var instance = RedisStore.getInstance(); var db = instance.RedisCacheTable; var sub = db.Multiplexer.GetSubscriber(); var limitCountWords = int.Parse(args[0]); var countWords = 0; bool status; sub.Subscribe(EVENTS, (channel, message) => { string mes = message; string eventName = mes.Split("=>")[0]; if (eventName == TEXT_CREATED_EVENT) { var contextId = mes.Split("=>")[1]; countWords++; status = countWords <= limitCountWords; sub.Publish(EVENTS, PublishMessage(contextId, status)); if (!status) { Task.Run(async() => { await Task.Delay(60000); countWords = 0; Console.WriteLine("Reset!"); }); } } if (eventName == TEXT_RANK_CALCULATED_EVENT) { string mesVal = mes.Split("=>")[1]; TextStatisticConsRater textStatisticConsRater = JsonConvert.DeserializeObject <TextStatisticConsRater>(mesVal); Console.WriteLine(message); if (textStatisticConsRater.rank <= 0.5) { countWords--; } } }); Console.WriteLine(countWords); Console.WriteLine("Observable subscribe text processing limiter is ready. For exit press Enter."); Console.ReadLine(); }
public void Redis_cache_empty_get_with_ConfigOptions() { //Arrange var cache = new RedisStore(ConfigurationOptions.Parse(REDIS_LOCALHOST)); //Act bool found = cache.TryGetValue(string.Empty, out var response); //Assert Assert.NotNull(cache); Assert.False(found); Assert.Null(response); }
public void GetValue() { var redisStore = new RedisStore(ConnectionString); var client = new HttpClient(new CachingHandler(redisStore) { InnerHandler = new HttpClientHandler() }); var httpResponseMessage = client.GetAsync(CacheableResource1).Result; var response = redisStore.GetValueAsync(new CacheKey(CacheableResource1, new string[0])).Result; Assert.NotNull(response); }
public void IfNotThrowThenDoesNot() { var s = new RedisStore("NoneExisting", throwExceptions: false); var k = new CacheKey("https://google.com/", new string[0]); var r = new HttpResponseMessage(HttpStatusCode.Accepted); s.AddOrUpdateAsync(k, r).Wait(); var r2 = s.GetValueAsync(k).Result; var removed = s.TryRemoveAsync(k).Result; Assert.Null(r2); Assert.False(removed); }
public void GetValue() { var redisStore = new RedisStore(); var client = new HttpClient(new CachingHandler(redisStore) { InnerHandler = new HttpClientHandler() }); var httpResponseMessage = client.GetAsync(CacheableResource1).Result; HttpResponseMessage response = null; var tryGetValue = redisStore.TryGetValue(new CacheKey(CacheableResource1, new string[0]), out response); Assert.That(tryGetValue); Assert.IsNotNull(response); }
public void GetLastAccessed() { var redisStore = new RedisStore(); var client = new HttpClient(new CachingHandler(redisStore) { InnerHandler = new HttpClientHandler() }); var httpResponseMessage = client.GetAsync(CacheableResource1).Result; CacheItemMetadata metadata = redisStore.GetEarliestAccessedItem("ajax.googleapis.com"); Assert.IsNotNull(metadata); Assert.AreEqual("ajax.googleapis.com", metadata.Domain); Assert.Less(DateTime.Now.Subtract(TimeSpan.FromSeconds(10)), metadata.LastAccessed); }
public void Redis_cache_empty_key() { //Arrange var cache = new RedisStore(REDIS_LOCALHOST); var expiration = new TimeSpan(0, 1, 0); var response = A.Fake <FakeCachedResponse>(); //Act cache.Set(string.Empty, response, expiration); //Assert Assert.NotNull(cache); Assert.NotNull(response); }
public void WorksWithMaxAgeZeroAndStillStoresIt() { var redisStore = new RedisStore(ConnectionString); var client = new HttpClient(new CachingHandler(redisStore) { InnerHandler = new HttpClientHandler(), DefaultVaryHeaders = new string[0] }); var httpResponseMessage = client.GetAsync(MaxAgeZeroResource).Result; var key = new CacheKey(MaxAgeZeroResource, new string[0]); var response = redisStore.GetValueAsync(key).Result; Assert.NotNull(response); }
public static void Main(string[] args) { int startingSecurityId = 0; int numberOfSecurities = NUMBER_OF_SECURITIES_TO_CREATE; if (args != null && args.Length > 0) { int.TryParse(args[0], out numberOfSecurities); if (args.Length > 1) { int.TryParse(args[1], out startingSecurityId); } } IStore store = new RedisStore(); store.Populate(numberOfSecurities, startingSecurityId); }
static void Main() { RedisStore instance = RedisStore.getInstance(); IDatabase db = instance.RedisCacheTable; var sub = db.Multiplexer.GetSubscriber(); sub.Subscribe(EVENTS, (channel, message) => { string mes = message; string eventName = mes.Split("=>")[0]; if (eventName == TEXT_RANK_CALCULATED_EVENT) { string mesVal = mes.Split("=>")[1]; TextStatisticConsRater textStatisticConsRater = JsonConvert.DeserializeObject <TextStatisticConsRater>(mesVal); Console.WriteLine(message); allTextStatistics += textStatisticConsRater.rank; textNum++; if (textStatisticConsRater.rank > 0.5) { highRankPart++; } avgRank = allTextStatistics / textNum; } if (eventName == PROCESSING_ACCEPTED_EVENT) { string mesVal = mes.Split("=>")[1]; ProcessingAccepted processingAccepted = JsonConvert.DeserializeObject <ProcessingAccepted>(mesVal); if (!processingAccepted.status) { countRejectRequests++; } } Console.WriteLine("textNum: " + textNum + ", highRankPart: " + highRankPart + ", avgRank: " + avgRank + ", countRejectRequests" + countRejectRequests); db.StringSet("text_statistic", GetStringifyTextStatistic(textNum, highRankPart, avgRank, countRejectRequests)); }); Console.WriteLine("Observable subscribe text statistics is ready. For exit press Enter."); Console.ReadLine(); }
public void Redis_cache_with_value_set_remove_get() { //Arrange var cache = new RedisStore(REDIS_LOCALHOST); var expiration = new TimeSpan(0, 1, 0); const string key = "-Random-Key-4"; var response = A.Fake <FakeCachedResponse>(); //Act cache.Set(key, response, expiration); cache.Remove(key); bool found = cache.TryGetValue(key, out var getResponse); //Assert Assert.Null(getResponse); Assert.False(found); }
public void Redis_cache_empty_set_no_timespan() { //Arrange var cache = new RedisStore(REDIS_LOCALHOST); var expiration = new TimeSpan(0, 0, 0); const string key = "-Random-Key-1"; var response = A.Fake <FakeCachedResponse>(); //Act cache.Set(key, response, expiration); bool found = cache.TryGetValue(key, out var getResponse); //Assert Assert.NotNull(cache); Assert.NotNull(response); Assert.False(found); Assert.Null(getResponse); }
public virtual async Task InitializeAsync() { lock (_lock) { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: true); var configuration = builder.Build(); IWebHostBuilder webHostBuild = WebHost.CreateDefaultBuilder() .UseStartup <TestStartUp>() .UseWebRoot(Directory.GetCurrentDirectory()) .UseContentRoot(Directory.GetCurrentDirectory()); var dbConnectionString = configuration.GetConnectionString("db"); if (string.IsNullOrEmpty(dbConnectionString)) { throw new ApplicationException("Missing the connection string to database"); } ; webHostBuild.ConfigureServices(service => { service.AddDbContextPool <DeviceContext>(ctxOptions => ctxOptions.UseInMemoryDatabase(dbConnectionString).EnableSensitiveDataLogging()); service.Configure <UserLoginOption>(options => configuration.Bind("TestUserCredential", options)); service.AddScoped <IHttpServiceTest, HttpServiceTest>(); service.AddMemoryCache(); service.Configure <NotificationSenderExtentionOptions>(options => configuration.Bind("NotificationHelper", options)); RedisConnection.InitializeConnectionString(configuration.GetSection("ConnectionStrings")["redis"]); service.AddSingleton <RedisStore>(); }); TestServer = new TestServer(webHostBuild); DbContext = TestServer.Host.Services.GetRequiredService <DeviceContext>(); Fixture = new Fixture(); Fixture.Customizations.Add(new IgnoreVirtualMembers()); memoryCache = TestServer.Host.Services.GetRequiredService <IMemoryCache>(); _notificationSenderExtentionOptions = TestServer.Host.Services.GetRequiredService <IOptionsMonitor <NotificationSenderExtentionOptions> >(); redisStore = TestServer.Host.Services.GetRequiredService <RedisStore>(); } }
static void Main() { Console.BackgroundColor = ConsoleColor.DarkGreen; Console.ForegroundColor = ConsoleColor.Black; Console.Clear(); var client = new RedisStore("localhost:6379").CreateClient(); client.BaseAddress = new Uri("http://localhost:1337"); while (true) { var response = client.GetAsync("/time").Result; var data = response.Content.ReadAsStringAsync().Result; Console.WriteLine(data); Console.WriteLine(response.Headers.CacheControl.ToString()); if (Console.ReadLine() == "done") { break; } } }
public string Post([FromBody] string json) { var id = Guid.NewGuid().ToString(); UserDataRegion userDataRegion = JsonConvert.DeserializeObject <UserDataRegion>(json); var contextId = $"RANK_{id}"; var instance = RedisStore.getInstance(); var db = instance.RedisCacheTable; var idDb = instance.GetNumDB(userDataRegion.region); var regionDb = instance.RedisCache(idDb); db.StringSet(contextId, idDb); regionDb.StringSet(id, GetStringifyUserData(userDataRegion, id)); var pub = db.Multiplexer.GetSubscriber(); string message = "TextCreated=>" + id; pub.Publish(Events, message); return(id); }