/// <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();
}
