/// <summary> /// Initializes a new instance of the <see cref="MemcachedCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <param name="serializer">The serializer.</param> /// <param name="client">The <see cref="MemcachedClient"/> to use.</param> public MemcachedCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer, MemcachedClient client) : this(configuration, managerConfiguration, loggerFactory) { // serializer gets ignored, just added to the ctor to satisfy the ctor finder in our custom DI to actually hit this ctor if the client is specified. NotNull(client, nameof(client)); Cache = client; }
/// <summary> /// Initializes a new instance of the <see cref="DictionaryCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> public DictionaryCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); this.cache = new ConcurrentDictionary <string, CacheItem <TCacheValue> >(); }
/// <summary> /// Initializes a new instance of the <see cref="BucketCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <exception cref="System.InvalidOperationException"> /// If <c>configuration.HandleName</c> is not valid. /// </exception> public BucketCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(configuration, nameof(configuration)); NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); // we can configure the bucket name by having "<configKey>:<bucketName>" as handle's // name value var nameParts = configuration.Key.Split(new[] { ":" }, StringSplitOptions.RemoveEmptyEntries); Ensure(nameParts.Length > 0, "Handle key is not valid {0}", configuration.Key); this.configurationName = nameParts[0]; if (nameParts.Length == 2) { this.bucketName = nameParts[1]; } this.configuration = CouchbaseConfigurationManager.GetConfiguration(this.configurationName); this.bucketConfiguration = CouchbaseConfigurationManager.GetBucketConfiguration(this.configuration, this.bucketName); this.bucket = CouchbaseConfigurationManager.GetBucket(this.configuration, this.configurationName, this.bucketName); }
/// <summary> /// Initializes a new instance of the <see cref="RedisCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="manager">The manager.</param> /// <param name="configuration">The configuration.</param> public RedisCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) : base(manager, configuration) { NotNull(manager, nameof(manager)); EnsureNotNull(manager.Configuration.CacheSerializer, "A cache serializer must be defined for this cache handle."); this.valueConverter = new RedisValueConverter(manager.Configuration.CacheSerializer); }
protected BaseCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException("configuration"); } if (manager == null) { throw new ArgumentNullException("manager"); } if (string.IsNullOrWhiteSpace(configuration.HandleName)) { throw new ArgumentException("Configuration name cannot be empty."); } this.Configuration = configuration; this.Manager = manager; this.Stats = new CacheStats <TCacheValue>( manager.Name, this.Configuration.HandleName, this.Configuration.EnableStatistics, this.Configuration.EnablePerformanceCounters); }
public SQLiteCacheHandle( ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer, SQLiteCacheHandleAdditionalConfiguration additionalConfiguration) : base(managerConfiguration, configuration) { this.serializer = serializer; this.additionalConfiguration = additionalConfiguration ?? new SQLiteCacheHandleAdditionalConfiguration(); Logger = loggerFactory.CreateLogger(this); this.cacheName = configuration.Name; this.conn = CreateConnection(this.additionalConfiguration.DatabaseFilePath); if (additionalConfiguration != null) { additionalConfiguration.BeginTransactionMethod = () => this.conn.BeginTransaction(/* TODO: Support arguments/overloads */); } this.SetInitialItemCount(); RemoveExpiredItems(); }
/// <summary> /// Initializes a new instance of the <see cref="BucketCacheHandle{TCacheValue}" /> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <param name="additionalSettings">The additional settings.</param> /// <exception cref="System.InvalidOperationException">If <c>configuration.HandleName</c> is not valid.</exception> public BucketCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, BucketCacheHandleAdditionalConfiguration additionalSettings) : base(managerConfiguration, configuration) { NotNull(configuration, nameof(configuration)); NotNull(loggerFactory, nameof(loggerFactory)); Logger = loggerFactory.CreateLogger(this); if (additionalSettings == null) { additionalSettings = new BucketCacheHandleAdditionalConfiguration(); } // we can configure the bucket name by having "<configKey>:<bucketName>" as handle's // this should only be used in 100% by app/web.config based configuration var nameParts = configuration.Key.Split(new[] { ":" }, StringSplitOptions.RemoveEmptyEntries); var configurationName = nameParts.Length > 0 ? nameParts[0] : Guid.NewGuid().ToString(); if (nameParts.Length == 2) { additionalSettings.BucketName = nameParts[1]; } _bucketManager = new CouchbaseConfigurationManager(configurationName, additionalSettings.BucketName, additionalSettings.BucketPassword); }
public MockCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) : base(manager, configuration) { this.AddCall = () => true; this.PutCall = () => { }; this.RemoveCall = () => { }; this.UpdateCall = () => { }; }
public MockCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { this.Logger = loggerFactory.CreateLogger(this); this.AddCall = () => true; this.PutCall = () => { }; this.RemoveCall = () => { }; this.UpdateCall = () => { }; }
public SystemWebCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) : base(manager, configuration) { NotNull(configuration, nameof(configuration)); this.instanceKey = Guid.NewGuid().ToString(); this.CreateInstanceToken(); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <param name="memoryCacheOptions">The vendor specific options.</param> public MemoryCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, MemoryCacheOptions memoryCacheOptions) : base(managerConfiguration, configuration) { Guard.NotNull(configuration, nameof(configuration)); Guard.NotNull(loggerFactory, nameof(loggerFactory)); Logger = loggerFactory.CreateLogger(this); _cacheName = configuration.Name; MemoryCacheOptions = memoryCacheOptions ?? new MemoryCacheOptions(); _cache = new MemoryCache(MemoryCacheOptions); }
public InMemoryJsonHandle( ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ICacheSerializer serializer, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { _cache = new ConcurrentDictionary <string, Tuple <Type, byte[]> >(); _serializer = serializer; Logger = loggerFactory.CreateLogger(this); }
public ParentCacheHandle( ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ParentCache <TCacheValue> parentCache) : base(managerConfiguration, configuration) { _parent = parentCache; Logger = loggerFactory.CreateLogger(this); }
private MemcachedCacheHandle( CacheHandleConfiguration configuration, ICacheManagerConfiguration managerConfiguration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(configuration, nameof(configuration)); NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); }
public SystemWebCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); this.instanceKey = Guid.NewGuid().ToString(); this.CreateInstanceToken(); }
public RedisCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer) : base(managerConfiguration, configuration) { NotNull(loggerFactory, nameof(loggerFactory)); NotNull(managerConfiguration, nameof(managerConfiguration)); EnsureNotNull(serializer, "A serializer is required for the redis cache handle"); this.managerConfiguration = managerConfiguration; this.Logger = loggerFactory.CreateLogger(this); this.valueConverter = new RedisValueConverter(serializer); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> public MemoryCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(configuration, nameof(configuration)); NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); this.cacheName = configuration.Name; this.cache = new MemoryCache(new MemoryCacheOptions()); this.instanceKey = Guid.NewGuid().ToString(); this.CreateInstanceToken(); }
/// <summary> /// Initializes a new instance of the <see cref="BaseCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager's configuration.</param> /// <param name="configuration">The configuration.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="managerConfiguration"/> or <paramref name="configuration"/> are null. /// </exception> /// <exception cref="System.ArgumentException">If <paramref name="configuration"/> name is empty.</exception> protected BaseCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration) { NotNull(configuration, nameof(configuration)); NotNull(managerConfiguration, nameof(managerConfiguration)); NotNullOrWhiteSpace(configuration.Name, nameof(configuration.Name)); Configuration = configuration; Stats = new CacheStats <TCacheValue>( managerConfiguration.Name, Configuration.Name, Configuration.EnableStatistics, Configuration.EnablePerformanceCounters); }
/// <summary> /// Initializes a new instance of the <see cref="RedisCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <param name="serializer">The serializer.</param> public RedisCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer) : base(managerConfiguration, configuration) { NotNull(loggerFactory, nameof(loggerFactory)); NotNull(managerConfiguration, nameof(managerConfiguration)); NotNull(configuration, nameof(configuration)); EnsureNotNull(serializer, "A serializer is required for the redis cache handle"); this.managerConfiguration = managerConfiguration; this.Logger = loggerFactory.CreateLogger(this); this.valueConverter = new RedisValueConverter(serializer); this.redisConfiguration = RedisConfigurations.GetConfiguration(configuration.Key); this.connection = new RedisConnectionManager(this.redisConfiguration, loggerFactory); this.isLuaAllowed = this.connection.Features.Scripting; }
/// <summary> /// Initializes a new instance of the <see cref="RedisCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <param name="serializer">The serializer.</param> public RedisCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer) : base(managerConfiguration, configuration) { NotNull(loggerFactory, nameof(loggerFactory)); NotNull(managerConfiguration, nameof(managerConfiguration)); NotNull(configuration, nameof(configuration)); EnsureNotNull(serializer, "A serializer is required for the redis cache handle"); Logger = loggerFactory.CreateLogger(this); _managerConfiguration = managerConfiguration; _valueConverter = new RedisValueConverter(serializer); _redisConfiguration = RedisConfigurations.GetConfiguration(configuration.Key); _connection = new RedisConnectionManager(_redisConfiguration, loggerFactory); _isLuaAllowed = _connection.Features.Scripting; // disable preloading right away if twemproxy mode, as this is not supported. _canPreloadScripts = _redisConfiguration.TwemproxyEnabled ? false : true; if (_redisConfiguration.KeyspaceNotificationsEnabled) { // notify-keyspace-events needs to be set to "Exe" at least! Otherwise we will not receive any events. // this must be configured per server and should probably not be done automagically as this needs admin rights! // Let's try to check at least if those settings are configured (the check also works only if useAdmin is set to true though). try { var configurations = _connection.GetConfiguration("notify-keyspace-events"); foreach (var cfg in configurations) { if (!cfg.Value.Contains("E")) { Logger.LogWarn("Server {0} is missing configuration value 'E' in notify-keyspace-events to enable keyevents.", cfg.Key); } if (!(cfg.Value.Contains("A") || (cfg.Value.Contains("x") && cfg.Value.Contains("e")))) { Logger.LogWarn("Server {0} is missing configuration value 'A' or 'x' and 'e' in notify-keyspace-events to enable keyevents for expired and evicted keys.", cfg.Key); } } } catch { Logger.LogDebug("Could not read configuration from redis to validate notify-keyspace-events. Most likely useAdmin is not set to true."); } SubscribeKeyspaceNotifications(); } }
protected BaseCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) { NotNull(configuration, nameof(configuration)); NotNull(manager, nameof(manager)); NotNullOrWhiteSpace(configuration.HandleName, nameof(configuration.HandleName)); this.Configuration = configuration; this.Manager = manager; this.Stats = new CacheStats <TCacheValue>( manager.Name, this.Configuration.HandleName, this.Configuration.EnableStatistics, this.Configuration.EnablePerformanceCounters); }
public MemcachedCacheHandle( ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer, MemcachedClientConfiguration clientConfiguration) : this(configuration, managerConfiguration, loggerFactory) { NotNull(clientConfiguration, nameof(clientConfiguration)); if (clientConfiguration.Transcoder.GetType() == typeof(DefaultTranscoder)) { clientConfiguration.Transcoder = new CacheManagerTanscoder <TCacheValue>(serializer); } this.Cache = new MemcachedClient(clientConfiguration); }
public MemcachedCacheHandle( ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer, MemcachedClientConfiguration clientConfiguration) : this(configuration, managerConfiguration, loggerFactory) { NotNull(clientConfiguration, nameof(clientConfiguration)); if (clientConfiguration.Transcoder.GetType() == typeof(DefaultTranscoder)) { clientConfiguration.Transcoder = new CacheManagerTanscoder <TCacheValue>(serializer); // default is 10, that might be too long as it can take up to 10sec to recover during retries clientConfiguration.SocketPool.DeadTimeout = TimeSpan.FromSeconds(2); } Cache = new MemcachedClient(clientConfiguration); }
public MemcachedCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) : base(manager, configuration) { NotNull(configuration, nameof(configuration)); Ensure(typeof(TCacheValue).IsSerializable, "The cache value type must be serializable but {0} is not.", typeof(TCacheValue).ToString()); // initialize memcached client with section name which must be equal to handle name... // Default is "enyim.com/memcached" try { var sectionName = GetEnyimSectionName(configuration.HandleName); this.Cache = new MemcachedClient(sectionName); } catch (ConfigurationErrorsException ex) { throw new InvalidOperationException("Failed to initialize " + this.GetType().Name + ". " + ex.BareMessage, ex); } }
/// <summary> /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="manager">The manager.</param> /// <param name="configuration">The configuration.</param> public MemoryCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) : base(manager, configuration) { NotNull(configuration, nameof(configuration)); this.cacheName = configuration.HandleName; if (this.cacheName.ToUpper(CultureInfo.InvariantCulture).Equals(DefaultName.ToUpper(CultureInfo.InvariantCulture))) { this.cache = System.Runtime.Caching.MemoryCache.Default; } else { this.cache = new System.Runtime.Caching.MemoryCache(this.cacheName); } this.instanceKey = Guid.NewGuid().ToString(); this.CreateInstanceToken(); }
public MemcachedCacheHandle( ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, ICacheSerializer serializer) : this(configuration, managerConfiguration, loggerFactory) { try { NotNull(configuration, nameof(configuration)); var sectionName = GetEnyimSectionName(configuration.Key); var section = GetSection(sectionName); Cache = new MemcachedClient(section); } catch (ConfigurationErrorsException ex) { throw new InvalidOperationException("Failed to initialize " + GetType().Name + ". " + ex.BareMessage, ex); } }
public AppFabricCacheHandle(ICacheManager <TCacheValue> manager, CacheHandleConfiguration configuration) : base(manager, configuration) { DataCacheFactoryConfiguration cfg = null; cfg = new DataCacheFactoryConfiguration(configuration.HandleName); var factory = cfg == null ? new DataCacheFactory() : new DataCacheFactory(cfg); RunRetry(() => { if (configuration.HandleName.ToUpper(CultureInfo.InvariantCulture).Equals(DefaultName)) { this.cache = factory.GetDefaultCache(); } else { this.cache = factory.GetCache(configuration.HandleName); } }); }
private static CacheHandleConfiguration GetHandleFromConfiguration(IConfigurationSection handleConfiguration) { var type = handleConfiguration[ConfigurationType]; var knownType = handleConfiguration[ConfigurationKnownType]; var key = handleConfiguration[ConfigurationKey] ?? handleConfiguration[ConfigurationName]; // name fallback for key var name = handleConfiguration[ConfigurationName]; var cacheHandleConfiguration = new CacheHandleConfiguration(); handleConfiguration.Bind(cacheHandleConfiguration); cacheHandleConfiguration.Key = key; cacheHandleConfiguration.Name = name ?? cacheHandleConfiguration.Name; if (string.IsNullOrEmpty(type) && string.IsNullOrEmpty(knownType)) { throw new InvalidOperationException( $"No '{ConfigurationType}' or '{ConfigurationKnownType}' defined in cache handle configuration '{handleConfiguration.Path}'."); } if (string.IsNullOrWhiteSpace(type)) { var keyRequired = false; cacheHandleConfiguration.HandleType = GetKnownHandleType(knownType, handleConfiguration.Path, out keyRequired); // some handles require name or key to be set to link to other parts of the configuration // lets check if that condition is satisfied if (keyRequired && string.IsNullOrWhiteSpace(key) && string.IsNullOrWhiteSpace(name)) { throw new InvalidOperationException( $@"Known handle of type '{knownType}' requires '{ConfigurationKey}' or '{ConfigurationName}' to be defined. Check configuration at '{handleConfiguration.Path}'."); } } else { cacheHandleConfiguration.HandleType = Type.GetType(type, true); } return(cacheHandleConfiguration); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> public MemoryCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(configuration, nameof(configuration)); NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); this.cacheName = configuration.Name; if (this.cacheName.ToUpper(CultureInfo.InvariantCulture).Equals(DefaultName.ToUpper(CultureInfo.InvariantCulture))) { this.cache = MemoryCache.Default; } else { this.cache = new MemoryCache(this.cacheName); } this.instanceKey = Guid.NewGuid().ToString(); this.CreateInstanceToken(); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> public MemoryCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { Guard.NotNull(configuration, nameof(configuration)); Guard.NotNull(loggerFactory, nameof(loggerFactory)); Logger = loggerFactory.CreateLogger(this); _cacheName = configuration.Name; if (_cacheName.ToUpper(CultureInfo.InvariantCulture).Equals(DefaultName.ToUpper(CultureInfo.InvariantCulture))) { _cache = MemoryCache.Default; } else { _cache = new MemoryCache(_cacheName); } _instanceKey = Guid.NewGuid().ToString(); _instanceKeyLength = _instanceKey.Length; CreateInstanceToken(); }