internal CacheClientTestBase(ISerializer serializer) { redisConfiguration = new RedisConfiguration() { AbortOnConnectFail = true, KeyPrefix = "MyPrefix__", Hosts = new RedisHost[] { new RedisHost { Host = "localhost", Port = 6379 } }, AllowAdmin = true, ConnectTimeout = 3000, Database = 0, PoolSize = 5, ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw } }; var moqLogger = new Mock <ILogger <RedisCacheConnectionPoolManager> >(); this.serializer = serializer; connectionPoolManager = new RedisCacheConnectionPoolManager(redisConfiguration, moqLogger.Object); sut = new RedisCacheClient(connectionPoolManager, this.serializer, redisConfiguration); db = sut.GetDbFromConfiguration().Database; }
public static IRedisDatabase Instance(IConfiguration config, ISerializer sz = null) { if (config == null) { throw new ArgumentException("Redis:Configuration is not Exists"); } var app = config.GetSection("App").Get <string>(); if (string.IsNullOrEmpty(app)) { throw new ArgumentException("Redis:APP is not Exists"); } var apptype = (App)Enum.Parse(typeof(App), app); var key = String.Format("Reis{0}", app); var redisConfig = config.GetSection(key).Get <RedisConfiguration>(); if (redisConfig == null) { throw new ArgumentException("Redis:redisConfig is not Exists"); } if (!CacheClientArry.ContainsKey(apptype)) { var cacheClient = GetCacheClient(redisConfig, sz); if (cacheClient != null) { CacheClientArry.TryAdd(apptype, cacheClient); } } IRedisCacheClient client = CacheClientArry[apptype]; var db = client.GetDb((int)apptype); return(db); }
/// <summary> /// 默认缓存服务 /// </summary> /// <param name="optionsAccessor">设置访问器</param> /// <param name="distributedCache">分布式缓存器</param> /// <param name="localCache">本地内存缓存器</param> /// <param name="logger">日志</param> public DefaultCacheService(IOptions <CacheServiceOptions> optionsAccessor, IRedisCacheClient distributedCache, IMemoryCache localCache, ILogger <DefaultCacheService> logger) { if (optionsAccessor == null) { throw new ArgumentNullException(nameof(optionsAccessor)); } this.logger = logger; this.options = optionsAccessor.Value; if (options.EnableDistributedCache && distributedCache != null) { this.cache = new DistributedMemoryCache(distributedCache); } else { this.cache = new RuntimeMemoryCache(localCache); } this.localCache = new RuntimeMemoryCache(localCache); this.EnableDistributedCache = options.EnableDistributedCache; this.cachingExpirationDictionary = new Dictionary <CachingExpirationType, TimeSpan>(); this.cachingExpirationDictionary.Add(CachingExpirationType.Invariable, new TimeSpan(0, 0, (int)(86400f * options.CacheExpirationFactor))); this.cachingExpirationDictionary.Add(CachingExpirationType.Stable, new TimeSpan(0, 0, (int)(28800f * options.CacheExpirationFactor))); this.cachingExpirationDictionary.Add(CachingExpirationType.RelativelyStable, new TimeSpan(0, 0, (int)(7200f * options.CacheExpirationFactor))); this.cachingExpirationDictionary.Add(CachingExpirationType.UsualSingleObject, new TimeSpan(0, 0, (int)(600f * options.CacheExpirationFactor))); this.cachingExpirationDictionary.Add(CachingExpirationType.UsualObjectCollection, new TimeSpan(0, 0, (int)(300f * options.CacheExpirationFactor))); this.cachingExpirationDictionary.Add(CachingExpirationType.SingleObject, new TimeSpan(0, 0, (int)(180f * options.CacheExpirationFactor))); this.cachingExpirationDictionary.Add(CachingExpirationType.ObjectCollection, new TimeSpan(0, 0, (int)(180f * options.CacheExpirationFactor))); this.logger.LogInformation($"DefaultCacheService::Init,EnableDistributedCache:{options.EnableDistributedCache},CacheExpirationFactor:{options.CacheExpirationFactor}."); }
public DBMaintenanceController(ILogger <DBMaintenanceController> logger, DEMODBContext context, IRedisCacheClient cacheClient, IPinCacheKeyGenerator keyGen) { _logger = logger; _context = context; _cacheClient = cacheClient; _keyGen = keyGen; }
public RedisChacheDownstreamService(ILogger <MemCacheDownStreamService> logger, IConfiguration configuration, HttpClient httpClient, IRedisCacheClient cache) : base(logger, httpClient) { _config = configuration; _logger = logger; _httpClient = httpClient; _cache = cache; }
public UpdateCartService(IRedisCacheClient redisCacheClient, ILogger <UpdateCartService> logger, IConfiguration configuration, IGetCartItems getCartItems) { _redisCacheClient = redisCacheClient; _logger = logger; _config = configuration; _getCartItems = getCartItems; }
public PinRepository(ILogger <IPinRepository> logger, IRedisCacheClient redisClient, IPinCacheKeyGenerator cacheKeyGenerator, DEMODBContext dbContext) { _logger = logger; _redisClient = redisClient; _cacheKeyGenerator = cacheKeyGenerator; _dbContext = dbContext; }
private static async Task NewMethod(IRedisCacheClient _redisClient) { await GenerateClocks(_redisClient.Db1); await LookupSingleItem(_redisClient.Db1); await LookupAllItems(_redisClient.Db1); }
/// <summary> /// Constructor /// </summary> /// <param name="configuration"></param> /// <param name="loggerFactory"></param> /// <param name="redisCacheClient"></param> public PlaceRepository( IConfiguration configuration, ILoggerFactory loggerFactory, IRedisCacheClient redisCacheClient ) : base(configuration, loggerFactory.CreateLogger <Repository.RedisRepository.PlaceRepository>(), redisCacheClient) { }
/// <summary> /// Constructor /// </summary> /// <param name="localizer"></param> /// <param name="configuration"></param> /// <param name="loggerFactory"></param> /// <param name="redisCacheClient"></param> /// <param name="emailSender"></param> /// <param name="smsSender"></param> /// <param name="placeRepository"></param> /// <param name="slotRepository"></param> /// <param name="placeProviderRepository"></param> /// <param name="userRepository"></param> public VisitorRepository( IStringLocalizer <Repository.RedisRepository.VisitorRepository> localizer, IConfiguration configuration, ILoggerFactory loggerFactory, IRedisCacheClient redisCacheClient, IEmailSender emailSender, ISMSSender smsSender, IPlaceRepository placeRepository, ISlotRepository slotRepository, IPlaceProviderRepository placeProviderRepository, IUserRepository userRepository ) : base( localizer, configuration, loggerFactory.CreateLogger <Repository.RedisRepository.VisitorRepository>(), redisCacheClient, emailSender, smsSender, placeRepository, slotRepository, placeProviderRepository, userRepository ) { logger = loggerFactory.CreateLogger <VisitorRepository>(); this.configuration = configuration; }
public GameService(IOptions <GameSettings> settings, ILogger <GameService> logger, IRedisCacheClient redisCacheClient, IOptions <CosmosSettings> cosmosSettings, IHttpContextAccessor httpContextAccessor) { _settings = settings.Value; _logger = logger; _redisCacheClient = redisCacheClient; _cosmosSettings = cosmosSettings.Value; _httpContextAccessor = httpContextAccessor; }
public RedisClient(LoggingClient _logger, IRedisCacheClient _redis, int _cacheLife, CacheType _cacheType, string _key) { redis = _redis; cacheLife = _cacheLife; key = _key; logger = _logger; cacheType = _cacheType; }
public WeatherForecastController( IRedisCacheClient redis ) { _redis = redis; Init(); }
/// <summary> /// Constructor /// </summary> /// <param name="configuration"></param> /// <param name="logger"></param> /// <param name="redisCacheClient"></param> public PlaceRepository( IConfiguration configuration, ILogger <PlaceRepository> logger, IRedisCacheClient redisCacheClient ) { this.logger = logger; this.redisCacheClient = redisCacheClient; this.configuration = configuration; }
private const int DEFAULT_LOCK_TTL = 300000; // 300 seconds. /// <summary> /// A general purpose ID locking system that utilizes Redis as its backend storage medium. This is just an in memory store /// that can be used to determine if some object (based upon its type (name) and unique identifier) are being used elsewhere /// in the system and thus cannot be accessed. /// </summary> /// <param name="redisCacheClient">Reference to a RedisCacheClient that can be used to communicate with the Redis infrastructure </param> /// <param name="redisDatabaseNumber">The number of the database that should be used to store locks in. It is recommended, but not required /// that locks be stored in a database all to their own. The reason, is if all locks need to be flushed it can be much faster to flush the /// entire Database than to work thru all the lock types.</param> /// <param name="isDedicatedLockDatabase">Set to True, if the database to be used for storing locks is dedicated to this use only or if it /// is shared with other uses (caching values, etc). There is a slight performance boost if using dedicated. </param> public RedisLocker(IRedisCacheClient redisCacheClient, byte redisDatabaseNumber = 0, bool isDedicatedLockDatabase = false) { _redisDB = redisCacheClient.GetDb(redisDatabaseNumber); _isDedicatedLockDatabase = isDedicatedLockDatabase; // Clear the Lock Prefix if this is a dedicated database - no need for it, since everything in the database is a lock entry. if (isDedicatedLockDatabase) { LockPrefix = ""; } }
public CacheConfigManager( IHostEnvironment env, IConfigManager innerManager, IRedisCacheClient cacheClient, ILogger <CacheConfigManager> logger = null) { this._env = env ?? throw new ArgumentNullException(nameof(env)); this._configManager = innerManager ?? throw new ArgumentNullException(nameof(innerManager)); this._cacheClient = cacheClient ?? throw new ArgumentNullException(nameof(cacheClient)); this._logger = logger; }
/// <summary> /// constructor /// </summary> /// <param name="localizer"></param> /// <param name="configuration"></param> /// <param name="loggerFactory"></param> /// <param name="redisCacheClient"></param> public SlotRepository( IStringLocalizer <Repository.RedisRepository.SlotRepository> localizer, IConfiguration configuration, ILoggerFactory loggerFactory, IRedisCacheClient redisCacheClient ) : base(localizer, configuration, loggerFactory.CreateLogger <Repository.RedisRepository.SlotRepository>(), redisCacheClient ) { }
/// <summary> /// Constructor /// </summary> /// <param name="localizer"></param> /// <param name="configuration"></param> /// <param name="logger"></param> /// <param name="redisCacheClient"></param> public SlotRepository( IStringLocalizer <SlotRepository> localizer, IConfiguration configuration, ILogger <SlotRepository> logger, IRedisCacheClient redisCacheClient ) { this.localizer = localizer; this.logger = logger; this.configuration = configuration; this.redisCacheClient = redisCacheClient; }
/// <summary> /// Constructor /// </summary> /// <param name="configuration"></param> /// <param name="logger"></param> /// <param name="redisCacheClient"></param> /// <param name="placeRepository"></param> public PlaceProviderRepository( IConfiguration configuration, ILogger <PlaceProviderRepository> logger, IRedisCacheClient redisCacheClient, IPlaceRepository placeRepository ) { this.logger = logger; this.redisCacheClient = redisCacheClient; this.configuration = configuration; this.placeRepository = placeRepository; }
/// <summary> /// Constructor /// </summary> /// <param name="configuration"></param> /// <param name="loggerFactory"></param> /// <param name="redisCacheClient"></param> /// <param name="placeRepository"></param> public PlaceProviderRepository( IConfiguration configuration, ILoggerFactory loggerFactory, IRedisCacheClient redisCacheClient, IPlaceRepository placeRepository ) : base( configuration, loggerFactory.CreateLogger <Repository.RedisRepository.PlaceProviderRepository>(), redisCacheClient, placeRepository) { this.configuration = configuration; }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, IRedisCacheClient cacheClient) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } cacheClient.Db0.Add("key", "int"); var result = cacheClient.Db0.Get <string>("key"); app.Run(async(context) => { await context.Response.WriteAsync("Hello World!"); }); }
public async Task RedisSetWebAsync(string key, IRedisCacheClient _cacheClient, RedisWeb obj) { await _cacheClient.Db0.AddAsync(key, obj); if (Webkeys.Count >= REDIS_MAX) { IDictionary <string, RedisWeb> dictionary = await _cacheClient.Db0.GetAllAsync <RedisWeb>(Webkeys); ICollection <RedisWeb> collection = dictionary.Values; ClickHouseInsertWeb(EnumerableWebConverter(collection)); await _cacheClient.Db0.RemoveAllAsync(Webkeys); Webkeys.Clear(); } }
public async Task RedisSetMobileAsync(string key, IRedisCacheClient _cacheClient, RedisMobile obj) { await _cacheClient.Db0.AddAsync(key, obj); if (Mobilekeys.Count >= REDIS_MAX) { IDictionary <string, RedisMobile> dictionary = await _cacheClient.Db0.GetAllAsync <RedisMobile>(Mobilekeys); ICollection <RedisMobile> collection = dictionary.Values; ClickHouseInsertMobile(EnumerableMobileConverter(collection)); await _cacheClient.Db0.RemoveAllAsync(Mobilekeys); Mobilekeys.Clear(); } }
public PiosService(IOptions <PiosServiceOptions> options, ILogger <PiosService> logger, IRedisCacheClient redis) { // Initialize the options. _options = options.Value; // Initialize injected stuff. _logger = logger; _redis = redis; // Save the cache TTL. _cache_ttl = _options.CacheTtl; // Determine the scheme to be used. var scheme = _options.Secure ? "https" : "http"; // Initialize the builder. _builder = new UriBuilder(scheme, _options.Host, _options.Port, _options.Path); }
public void Setup() { ServiceProvider = new ServiceCollection() .AddStackExchangeRedisExtensions <NewtonsoftSerializer>(new RedisConfiguration { Password = "******", AllowAdmin = true, Ssl = false, ConnectTimeout = 6000, Database = 0, Hosts = new[] { new RedisHost { Host = "##.##.##.##", Port = 6379 } } }) .BuildServiceProvider(); _redisCacheClient = ServiceProvider.GetService <IRedisCacheClient>(); }
/// <summary> /// Constructor /// </summary> /// <param name="localizer"></param> /// <param name="configuration"></param> /// <param name="logger"></param> /// <param name="redisCacheClient"></param> /// <param name="emailSender"></param> /// <param name="smsSender"></param> /// <param name="placeRepository"></param> /// <param name="placeProviderRepository"></param> public UserRepository( IStringLocalizer <UserRepository> localizer, IConfiguration configuration, ILogger <UserRepository> logger, IRedisCacheClient redisCacheClient, IEmailSender emailSender, ISMSSender smsSender, IPlaceRepository placeRepository, IPlaceProviderRepository placeProviderRepository ) { this.localizer = localizer; this.logger = logger; this.redisCacheClient = redisCacheClient; this.emailSender = emailSender; this.smsSender = smsSender; this.configuration = configuration; this.placeRepository = placeRepository; this.placeProviderRepository = placeProviderRepository; }
public override Task OnActivateAsync() { Identity = this.GetPrimaryKeyLong(); _Logger = ServiceProvider.GetService <ILoggerFactory>().CreateLogger("Node[" + Identity + "]"); _CacheClient = ServiceProvider.GetService <IRedisCacheClient>(); _IMongoClient = ServiceProvider.GetService <IMongoClient>(); EntityManager = new EntityManager(); SyncManager = new EventManager <SyncType>(); TimerManager = new TimerManager(this); BatchCahceList = new List <NList>(); SyncManager.Register(SyncType.Entity, OnSyncEntity); SyncManager.Register(SyncType.Field, OnSyncField); SyncManager.Register(SyncType.Table, OnSyncTable); RegisterTimer(BatchCache, null, TimeSpan.FromSeconds(0), TimeSpan.FromMilliseconds(TimeUtils.MINITE)); return(base.OnActivateAsync()); }
/// <summary> /// constructor /// </summary> /// <param name="localizer"></param> /// <param name="localizer2"></param> /// <param name="configuration"></param> /// <param name="loggerFactory"></param> /// <param name="redisCacheClient"></param> /// <param name="emailSender"></param> /// <param name="smsSender"></param> /// <param name="placeRepository"></param> /// <param name="placeProviderRepository"></param> public UserRepository( IStringLocalizer <UserRepository> localizer, IStringLocalizer <Repository.RedisRepository.UserRepository> localizer2, IConfiguration configuration, ILoggerFactory loggerFactory, IRedisCacheClient redisCacheClient, IEmailSender emailSender, ISMSSender smsSender, IPlaceRepository placeRepository, IPlaceProviderRepository placeProviderRepository ) : base( localizer2, configuration, loggerFactory.CreateLogger <Repository.RedisRepository.UserRepository>(), redisCacheClient, emailSender, smsSender, placeRepository, placeProviderRepository ) { this.localizer = localizer; this.placeProviderRepository = placeProviderRepository; }
public UserController(IRedisCacheClient redisCacheClient) { _redisCacheClient = redisCacheClient; }
public RedisService(IRedisCacheClient _cacheClient, ISerializer _serializer) { cacheClient = _cacheClient; serializer = _serializer; }