/// <summary>
/// Pooled queue cache is a cache of message that obtains resource from a pool
/// </summary>
/// <param name="cacheDataAdapter"></param>
/// <param name="comparer"></param>
/// <param name="logger"></param>
/// <param name="cacheMonitor"></param>
/// <param name="cacheMonitorWriteInterval">cache monitor write interval. Only triggered for active caches.</param>
public PooledQueueCache(ICacheDataAdapter <TQueueMessage, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer, ILogger logger, ICacheMonitor cacheMonitor, TimeSpan?cacheMonitorWriteInterval)
{
if (cacheDataAdapter == null)
{
throw new ArgumentNullException("cacheDataAdapter");
}
if (comparer == null)
{
throw new ArgumentNullException("comparer");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.cacheDataAdapter = cacheDataAdapter;
this.comparer = comparer;
this.logger = logger;
this.itemCount = 0;
pool = new CachedMessagePool <TQueueMessage, TCachedMessage>(cacheDataAdapter);
messageBlocks = new LinkedList <CachedMessageBlock <TCachedMessage> >();
this.cacheMonitor = cacheMonitor;
if (this.cacheMonitor != null && cacheMonitorWriteInterval.HasValue)
{
this.periodicMonitoring = new PeriodicAction(cacheMonitorWriteInterval.Value, this.ReportCacheMessageStatistics);
}
}
/// <summary>
/// EventHub queue cache.
/// </summary>
/// <param name="partition">Partition this instance is caching.</param>
/// <param name="defaultMaxAddCount">Default max number of items that can be added to the cache between purge calls.</param>
/// <param name="bufferPool">raw data block pool.</param>
/// <param name="dataAdapter">Adapts EventData to cached.</param>
/// <param name="evictionStrategy">Eviction strategy manage purge related events</param>
/// <param name="checkpointer">Logic used to store queue position.</param>
/// <param name="logger"></param>
/// <param name="cacheMonitor"></param>
/// <param name="cacheMonitorWriteInterval"></param>
/// <param name="metadataMinTimeInCache"></param>
public EventHubQueueCache(
string partition,
int defaultMaxAddCount,
IObjectPool <FixedSizeBuffer> bufferPool,
IEventHubDataAdapter dataAdapter,
IEvictionStrategy evictionStrategy,
IStreamQueueCheckpointer <string> checkpointer,
ILogger logger,
ICacheMonitor cacheMonitor,
TimeSpan?cacheMonitorWriteInterval,
TimeSpan?metadataMinTimeInCache)
{
this.Partition = partition;
this.defaultMaxAddCount = defaultMaxAddCount;
this.bufferPool = bufferPool;
this.dataAdapter = dataAdapter;
this.checkpointer = checkpointer;
this.cache = new PooledQueueCache(dataAdapter, logger, cacheMonitor, cacheMonitorWriteInterval, metadataMinTimeInCache);
this.cacheMonitor = cacheMonitor;
this.evictionStrategy = evictionStrategy;
this.evictionStrategy.OnPurged = this.OnPurge;
this.evictionStrategy.PurgeObservable = this.cache;
this.cachePressureMonitor = new AggregatedCachePressureMonitor(logger, cacheMonitor);
this.logger = logger;
}
/// <summary>
/// Pooled queue cache is a cache of message that obtains resource from a pool
/// </summary>
/// <param name="cacheDataAdapter"></param>
/// <param name="comparer"></param>
/// <param name="logger"></param>
/// <param name="cacheMonitor"></param>
/// <param name="cacheMonitorWriteInterval">cache monitor write interval</param>
public PooledQueueCache(ICacheDataAdapter <TQueueMessage, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer, Logger logger, ICacheMonitor cacheMonitor = null, TimeSpan?cacheMonitorWriteInterval = null)
{
if (cacheDataAdapter == null)
{
throw new ArgumentNullException("cacheDataAdapter");
}
if (comparer == null)
{
throw new ArgumentNullException("comparer");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.cacheDataAdapter = cacheDataAdapter;
this.comparer = comparer;
this.logger = logger.GetSubLogger("messagecache", "-");
this.itemCount = 0;
pool = new CachedMessagePool <TQueueMessage, TCachedMessage>(cacheDataAdapter);
messageBlocks = new LinkedList <CachedMessageBlock <TCachedMessage> >();
this.cacheMonitor = cacheMonitor;
if (this.cacheMonitor != null && cacheMonitorWriteInterval.HasValue)
{
this.timer = new Timer(this.ReportCacheMessageStatistics, null, cacheMonitorWriteInterval.Value, cacheMonitorWriteInterval.Value);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="flowControlThreshold"></param>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public AveragingCachePressureMonitor(double flowControlThreshold, ILogger logger, ICacheMonitor monitor = null)
{
this.flowControlThreshold = flowControlThreshold;
this.logger = logger;
nextCheckedTime = DateTime.MinValue;
isUnderPressure = false;
this.CacheMonitor = monitor;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval"></param>
/// <param name="timePurage"></param>
public EventHubCacheEvictionStrategy(Logger logger, ICacheMonitor cacheMonitor = null, TimeSpan?monitorWriteInterval = null, TimePurgePredicate timePurage = null)
{
this.inUseBuffers = new Queue <FixedSizeBuffer>();
this.logger = logger.GetSubLogger(this.GetType().Name);
this.purgedBuffers = new Queue <FixedSizeBuffer>();
this.timePurge = timePurage ?? TimePurgePredicate.Default;
this.cacheMonitor = cacheMonitor;
if (cacheMonitor != null && monitorWriteInterval.HasValue)
{
this.timer = new Timer(this.ReportCacheSize, null, monitorWriteInterval.Value, monitorWriteInterval.Value);
}
this.cacheSizeInByte = 0;
}
/// <summary>
/// Construct EventHub queue cache.
/// </summary>
/// <param name="defaultMaxAddCount">Default max number of items that can be added to the cache between purge calls.</param>
/// <param name="checkpointer">Logic used to store queue position.</param>
/// <param name="cacheDataAdapter">Performs data transforms appropriate for the various types of queue data.</param>
/// <param name="comparer">Compares cached data</param>
/// <param name="logger"></param>
/// <param name="evictionStrategy">Eviction stretagy manage purge related events</param>
/// <param name="cacheMonitor"></param>
/// <param name="cacheMonitorWriteInterval"></param>
protected EventHubQueueCache(int defaultMaxAddCount, IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, TCachedMessage> cacheDataAdapter,
ICacheDataComparer <TCachedMessage> comparer, Logger logger, IEvictionStrategy <TCachedMessage> evictionStrategy,
ICacheMonitor cacheMonitor, TimeSpan?cacheMonitorWriteInterval)
{
this.defaultMaxAddCount = defaultMaxAddCount;
Checkpointer = checkpointer;
cache = new PooledQueueCache <EventData, TCachedMessage>(cacheDataAdapter, comparer, logger, cacheMonitor, cacheMonitorWriteInterval);
this.cacheMonitor = cacheMonitor;
this.evictionStrategy = evictionStrategy;
this.evictionStrategy.OnPurged = this.OnPurge;
this.cachePressureMonitor = new AggregatedCachePressureMonitor(logger, cacheMonitor);
EvictionStrategyCommonUtils.WireUpEvictionStrategy <EventData, TCachedMessage>(this.cache, cacheDataAdapter, this.evictionStrategy);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="timePurage"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval"></param>
protected ChronologicalEvictionStrategy(Logger logger, TimePurgePredicate timePurage, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
{
if (logger == null)
{
throw new ArgumentException(nameof(logger));
}
if (timePurage == null)
{
throw new ArgumentException(nameof(timePurage));
}
this.logger = logger;
this.timePurge = timePurage;
this.inUseBuffers = new Queue <FixedSizeBuffer>();
this.cacheMonitor = cacheMonitor;
if (cacheMonitor != null && monitorWriteInterval.HasValue)
{
this.timer = new Timer(this.ReportCacheSize, null, monitorWriteInterval.Value, monitorWriteInterval.Value);
}
this.cacheSizeInByte = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="ChronologicalEvictionStrategy"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="timePurage">The time-based purge predicate.</param>
/// <param name="cacheMonitor">The cache monitor.</param>
/// <param name="monitorWriteInterval">"Interval to write periodic statistics. Only triggered for active caches.</param>
public ChronologicalEvictionStrategy(ILogger logger, TimePurgePredicate timePurage, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
{
if (logger == null)
{
throw new ArgumentException(nameof(logger));
}
if (timePurage == null)
{
throw new ArgumentException(nameof(timePurage));
}
this.logger = logger;
this.timePurge = timePurage;
this.inUseBuffers = new Queue <FixedSizeBuffer>();
// monitoring
this.cacheMonitor = cacheMonitor;
if (this.cacheMonitor != null && monitorWriteInterval.HasValue)
{
this.periodicMonitoring = new PeriodicAction(monitorWriteInterval.Value, this.ReportCacheSize);
}
this.cacheSizeInByte = 0;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="flowControlThreshold"></param>
/// <param name="pressureWindowSzie"></param>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public SlowConsumingPressureMonitor(double flowControlThreshold, TimeSpan pressureWindowSzie, ILogger logger, ICacheMonitor monitor = null)
{
this.FlowControlThreshold = flowControlThreshold;
this.logger = logger;
this.nextCheckedTime = DateTime.MinValue;
this.biggestPressureInCurrentWindow = 0;
this.wasUnderPressure = false;
this.CacheMonitor = monitor;
this.PressureWindowSize = pressureWindowSzie;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="flowControlThreshold"></param>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public SlowConsumingPressureMonitor(double flowControlThreshold, ILogger logger, ICacheMonitor monitor = null)
: this(flowControlThreshold, DefaultPressureWindowSize, logger, monitor)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pressureWindowSize"></param>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public SlowConsumingPressureMonitor(TimeSpan pressureWindowSize, ILogger logger, ICacheMonitor monitor = null)
: this(DefaultFlowControlThreshold, pressureWindowSize, logger, monitor)
{
}
public GeneratorPooledCacheEvictionStrategy(Logger logger, TimePurgePredicate purgePredicate, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
: base(logger, purgePredicate, cacheMonitor, monitorWriteInterval)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public AggregatedCachePressureMonitor(ILogger logger, ICacheMonitor monitor = null)
{
this.isUnderPressure = false;
this.logger = logger;
this.CacheMonitor = monitor;
}
/// <summary>
/// Pooled cache for generator stream provider
/// </summary>
/// <param name="bufferPool"></param>
/// <param name="logger"></param>
/// <param name="serializationManager"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval"></param>
public GeneratorPooledCache(IObjectPool <FixedSizeBuffer> bufferPool, Logger logger, SerializationManager serializationManager, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
{
var dataAdapter = new CacheDataAdapter(bufferPool, serializationManager);
cache = new PooledQueueCache <GeneratedBatchContainer, CachedMessage>(dataAdapter, CacheDataComparer.Instance, logger, cacheMonitor, monitorWriteInterval);
TimePurgePredicate purgePredicate = new TimePurgePredicate(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(10));
this.evictionStrategy = new GeneratorPooledCacheEvictionStrategy(logger, purgePredicate, cacheMonitor, monitorWriteInterval)
{
PurgeObservable = cache
};
EvictionStrategyCommonUtils.WireUpEvictionStrategy(cache, dataAdapter, this.evictionStrategy);
}
public QueueCacheForTesting(int defaultMaxAddCount, IObjectPool <FixedSizeBuffer> bufferPool, IEventHubDataAdapter dataAdapter, IEvictionStrategy evictionStrategy, IStreamQueueCheckpointer <string> checkpointer, ILogger logger,
ICacheMonitor cacheMonitor, TimeSpan?cacheMonitorWriteInterval)
: base("test", defaultMaxAddCount, bufferPool, dataAdapter, evictionStrategy, checkpointer, logger, cacheMonitor, cacheMonitorWriteInterval)
{
}
/// <summary>
/// Pooled cache for generator stream provider
/// </summary>
/// <param name="bufferPool"></param>
/// <param name="logger"></param>
/// <param name="serializationManager"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval">monitor write interval. Only triggered for active caches.</param>
public GeneratorPooledCache(IObjectPool <FixedSizeBuffer> bufferPool, ILogger logger, SerializationManager serializationManager, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
{
this.bufferPool = bufferPool;
this.serializationManager = serializationManager;
cache = new PooledQueueCache(this, logger, cacheMonitor, monitorWriteInterval);
TimePurgePredicate purgePredicate = new TimePurgePredicate(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(10));
this.evictionStrategy = new ChronologicalEvictionStrategy(logger, purgePredicate, cacheMonitor, monitorWriteInterval)
{
PurgeObservable = cache
};
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public AggregatedCachePressureMonitor(Logger logger, ICacheMonitor monitor = null)
{
this.isUnderPressure = false;
this.logger = logger.GetSubLogger(this.GetType().Name);
this.CacheMonitor = monitor;
}
/// <summary>
/// Pooled cache for memory stream provider
/// </summary>
/// <param name="bufferPool"></param>
/// <param name="purgePredicate"></param>
/// <param name="logger"></param>
/// <param name="serializer"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval">monitor write interval. Only triggered for active caches.</param>
public MemoryPooledCache(IObjectPool <FixedSizeBuffer> bufferPool, TimePurgePredicate purgePredicate, ILogger logger, TSerializer serializer, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
{
this.bufferPool = bufferPool;
this.serializer = serializer;
this.cache = new PooledQueueCache(this, logger, cacheMonitor, monitorWriteInterval);
this.evictionStrategy = new ChronologicalEvictionStrategy(logger, purgePredicate, cacheMonitor, monitorWriteInterval)
{
PurgeObservable = cache
};
}
/// <summary>
/// Pooled cache for memory stream provider
/// </summary>
/// <param name="bufferPool"></param>
/// <param name="purgePredicate"></param>
/// <param name="logger"></param>
/// <param name="serializer"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval">monitor write interval. Only triggered for active caches.</param>
public MemoryPooledCache(IObjectPool <FixedSizeBuffer> bufferPool, TimePurgePredicate purgePredicate, Logger logger, TSerializer serializer, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
{
var dataAdapter = new CacheDataAdapter(bufferPool, serializer);
cache = new PooledQueueCache <MemoryMessageData, MemoryMessageData>(dataAdapter, CacheDataComparer.Instance, logger, cacheMonitor, monitorWriteInterval);
this.evictionStrategy = new MemoryPooledCacheEvictionStrategy(logger, purgePredicate, cacheMonitor, monitorWriteInterval)
{
PurgeObservable = cache
};
EvictionStrategyCommonUtils.WireUpEvictionStrategy <MemoryMessageData, MemoryMessageData>(cache, dataAdapter, evictionStrategy);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public AveragingCachePressureMonitor(ILogger logger, ICacheMonitor monitor = null)
: this(DefaultThreshold, logger, monitor)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="cacheMonitor"></param>
/// <param name="monitorWriteInterval"></param>
/// <param name="timePurage"></param>
public EventHubCacheEvictionStrategy(Logger logger, TimePurgePredicate timePurage, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval)
: base(logger.GetLogger(LogName), timePurage, cacheMonitor, monitorWriteInterval)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="monitor"></param>
public AveragingCachePressureMonitor(ILogger logger, ICacheMonitor monitor = null)
: this(EventHubStreamCachePressureOptions.DEFAULT_AVERAGING_CACHE_PRESSURE_MONITORING_THRESHOLD, logger, monitor)
{
}
/// <summary>
/// 注册一个 CacheServiceMonitor
/// </summary>
/// <param name="monitor">要注册的 CacheServiceMonitor 对象</param>
/// <returns>返回自身便于链式调用</returns>
public CacheService RegisterMonitor(ICacheMonitor monitor)
{
_monitors.Add(monitor);
return(this);
}
public EHEvictionStrategyForTesting(ILogger logger, ICacheMonitor cacheMonitor = null, TimeSpan?monitorWriteInterval = null, TimePurgePredicate timePurage = null)
: base(logger, timePurage, cacheMonitor, monitorWriteInterval)
{
}
public QueueCacheForTesting(int defaultMaxAddCount, IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, CachedEventHubMessage> cacheDataAdapter,
ICacheDataComparer <CachedEventHubMessage> comparer, ILogger logger, IEvictionStrategy <CachedEventHubMessage> evictionStrategy,
ICacheMonitor cacheMonitor, TimeSpan?cacheMonitorWriteInterval)
: base(defaultMaxAddCount, checkpointer, cacheDataAdapter, comparer, logger, evictionStrategy, cacheMonitor, cacheMonitorWriteInterval)
{
}
