/// <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;
}
public CacheService(ICacheManagerConfiguration configuration, ICacheManager <string> cacheManager)
{
this._configuration = configuration;
this._cacheManager = cacheManager;
this.Name = _configuration.Name;
}
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="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(ICacheManagerConfiguration 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(ICacheManagerConfiguration 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="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);
}
internal static ICacheSerializer CreateSerializer(ICacheManagerConfiguration configuration, ILoggerFactory loggerFactory)
{
NotNull(configuration, nameof(configuration));
NotNull(loggerFactory, nameof(loggerFactory));
#if !NETSTANDARD
if (configuration.SerializerType == null)
{
return(new BinaryCacheSerializer());
}
#endif
if (configuration.SerializerType != null)
{
CheckImplements <ICacheSerializer>(configuration.SerializerType);
var args = new object[] { configuration, loggerFactory };
if (configuration.SerializerTypeArguments != null)
{
args = configuration.SerializerTypeArguments.Concat(args).ToArray();
}
return((ICacheSerializer)CreateInstance(configuration.SerializerType, args));
}
return(null);
}
internal static CacheBackplane CreateBackplane(ICacheManagerConfiguration configuration, ILoggerFactory loggerFactory)
{
NotNull(configuration, nameof(configuration));
NotNull(loggerFactory, nameof(loggerFactory));
if (configuration.BackplaneType != null)
{
if (!configuration.CacheHandleConfigurations.Any(p => p.IsBackplaneSource))
{
throw new InvalidOperationException(
"At least one cache handle must be marked as the backplane source if a backplane is defined via configuration.");
}
CheckExtends <CacheBackplane>(configuration.BackplaneType);
var args = new object[] { configuration, loggerFactory };
if (configuration.BackplaneTypeArguments != null)
{
args = configuration.BackplaneTypeArguments.Concat(args).ToArray();
}
return((CacheBackplane)CreateInstance(configuration.BackplaneType, args));
}
return(null);
}
//private object _startScanLock = new object();
/// <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(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory)
: base(managerConfiguration, configuration)
{
NotNull(loggerFactory, nameof(loggerFactory));
Logger = loggerFactory.CreateLogger(this);
_cache = new ConcurrentDictionary <string, CacheItem <TCacheValue> >();
_timer = new Timer(TimerLoop, null, _random.Next(100, ScanInterval), ScanInterval);
}
public ICacheManagerConfiguration GetConfiguration()
{
var builder = new ConfigurationBuilder()
.WithDictionaryHandle()
;
Configuration = builder.Build();
return(Configuration);
}
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);
}
/// <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 SystemWebCacheHandle(ICacheManagerConfiguration 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 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);
}
private BaseCacheManager(string name, ICacheManagerConfiguration configuration)
{
NotNullOrWhiteSpace(name, nameof(name));
NotNull(configuration, nameof(configuration));
Name = name;
Configuration = configuration;
var loggerFactory = CacheReflectionHelper.CreateLoggerFactory(configuration);
var serializer = CacheReflectionHelper.CreateSerializer(configuration, loggerFactory);
Logger = loggerFactory.CreateLogger(this);
_logTrace = Logger.IsEnabled(LogLevel.Trace);
Logger.LogInfo("Cache manager: adding cache handles...");
try
{
_cacheHandles = CacheReflectionHelper.CreateCacheHandles(this, loggerFactory, serializer).ToArray();
var index = 0;
foreach (var handle in _cacheHandles)
{
var handleIndex = index;
handle.OnCacheSpecificRemove += (sender, args) =>
{
// base cache handle does logging for this
TriggerOnRemoveByHandle(args.Key, args.Region, args.Reason, handleIndex + 1, args.Value);
if (Configuration.UpdateMode == CacheUpdateMode.Up)
{
if (_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.", handleIndex);
}
EvictFromHandlesAbove(args.Key, args.Region, handleIndex);
}
};
index++;
}
_cacheBackplane = CacheReflectionHelper.CreateBackplane(configuration, loggerFactory);
if (_cacheBackplane != null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Error occurred while creating the cache manager.");
throw ex.InnerException ?? ex;
}
}
protected override void Configure()
{
base.Configure();
_configuration = new ConfigurationBuilder()
.WithMicrosoftLogging(LoggerFactory)
.WithDictionaryHandle("in-memory", isBackplaneSource: true)
.And
.WithRedisBackplane("redisConfig")
.WithRedisConfiguration("redisConfig", "localhost", enableKeyspaceNotifications: true)
.Build();
}
/// <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();
}
protected async Task RunWithConfigurationTwoCaches <TCacheItem>(
ICacheManagerConfiguration configuration,
Func <ICacheManager <TCacheItem>, ICacheManager <TCacheItem>, EventCounter <TCacheItem>, EventCounter <TCacheItem>, Task> job)
{
var cache = CacheFactory.FromConfiguration <TCacheItem>("CacheA", configuration);
var cache2 = CacheFactory.FromConfiguration <TCacheItem>("CacheB", configuration);
var handlingA = new EventCounter <TCacheItem>(cache);
var handlingB = new EventCounter <TCacheItem>(cache2);
Func <Task> task = () => Task.Run(async() => await job(cache, cache2, handlingA, handlingB));
await Runner(task, handlingA, handlingB);
}
protected async Task RunWithConfigurationOneCache <TCacheItem>(
ICacheManagerConfiguration configuration,
Action <ICacheManager <TCacheItem>, EventCounter <TCacheItem> > job)
{
var cache = CacheFactory.FromConfiguration <TCacheItem>("CacheA", configuration);
cache.Clear();
var handlingA = new EventCounter <TCacheItem>(cache);
Func <Task> task = () => Task.Run(() => job(cache, handlingA));
await Runner(task, handlingA);
}
/// <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(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");
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;
}
protected override void Configure()
{
base.Configure();
_multiplexer = ConnectionMultiplexer.Connect("localhost,allowAdmin=true");
_configuration = new ConfigurationBuilder()
.WithMicrosoftLogging(LoggerFactory)
.WithMicrosoftMemoryCacheHandle("in-memory")
.And
.WithRedisBackplane("redisConfig")
.WithJsonSerializer()
.WithRedisConfiguration("redisConfig", _multiplexer, enableKeyspaceNotifications: true)
.WithRedisCacheHandle("redisConfig")
.Build();
}
/// <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();
}
}
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);
}
static void Test1(ICacheManagerConfiguration configuration)
{
var cache = CacheFactory.FromConfiguration <object>(cacheName1, configuration);
dictionary.Add(cacheName1, cache);
cache.Add("keyA", "valueA");
cache.Put("keyB", 23);
cache.Update("keyB", v => 42);
Console.WriteLine("KeyA is " + cache.Get("keyA")); // should be valueA
Console.WriteLine("KeyB is " + cache.Get("keyB")); // should be 42
cache.Remove("keyA");
Console.WriteLine("KeyA removed? " + (cache.Get("keyA") == null).ToString());
Console.WriteLine("We are done Test1 ...");
}
static void Test2(ICacheManagerConfiguration configuration)
{
var cache = CacheFactory.FromConfiguration <object>(cacheName2, configuration);
dictionary.Add(cacheName2, cache);
cache.Add("keyC", "valueC");
cache.Put("keyD", 23);
cache.Update("keyC", v => 24);
Console.WriteLine("KeyC is " + cache.Get("keyC")); // should be valueC
Console.WriteLine("KeyD is " + cache.Get("keyD")); // should be 24
cache.Remove("keyC");
Console.WriteLine("KeyC removed? " + (cache.Get("keyC") == null).ToString());
Console.WriteLine("We are done Test2 ...");
}
/// <summary>
/// Initializes a new instance of the <see cref="RedisCacheBackplane"/> class.
/// </summary>
/// <param name="configuration">The cache manager configuration.</param>
/// <param name="loggerFactory">The logger factory</param>
public RedisCacheBackplane(ICacheManagerConfiguration configuration, ILoggerFactory loggerFactory)
: base(configuration)
{
Guard.NotNull(configuration, nameof(configuration));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
_logger = loggerFactory.CreateLogger(this);
_channelName = configuration.BackplaneChannelName ?? "CacheManagerBackplane";
_identifier = Encoding.UTF8.GetBytes(Guid.NewGuid().ToString());
var cfg = RedisConfigurations.GetConfiguration(ConfigurationKey);
_connection = new RedisConnectionManager(
cfg,
loggerFactory);
RetryHelper.Retry(() => Subscribe(), configuration.RetryTimeout, configuration.MaxRetries, _logger);
}
/// <summary>
/// Initializes a new instance of the <see cref="RedisCacheBackplane"/> class.
/// </summary>
/// <param name="configuration">The cache manager configuration.</param>
/// <param name="loggerFactory">The logger factory</param>
public RedisCacheBackplane(ICacheManagerConfiguration configuration, ILoggerFactory loggerFactory)
: base(configuration)
{
NotNull(configuration, nameof(configuration));
NotNull(loggerFactory, nameof(loggerFactory));
this.logger = loggerFactory.CreateLogger(this);
this.channelName = configuration.BackplaneChannelName ?? "CacheManagerBackplane";
this.identifier = Guid.NewGuid().ToString();
var cfg = RedisConfigurations.GetConfiguration(this.ConfigurationKey);
this.connection = new RedisConnectionManager(
cfg,
loggerFactory);
RetryHelper.Retry(() => this.Subscribe(), configuration.RetryTimeout, configuration.MaxRetries, this.logger);
}
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);
}
