/// <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>
/// 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>
/// 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>
protected EventHubQueueCache(int defaultMaxAddCount, IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, TCachedMessage> cacheDataAdapter,
ICacheDataComparer <TCachedMessage> comparer, Logger logger, IEvictionStrategy <TCachedMessage> evictionStrategy)
{
this.defaultMaxAddCount = defaultMaxAddCount;
Checkpointer = checkpointer;
cache = new PooledQueueCache <EventData, TCachedMessage>(cacheDataAdapter, comparer, logger);
this.evictionStrategy = evictionStrategy;
this.evictionStrategy.OnPurged = this.OnPurge;
this.evictionStrategy.PurgeObservable = cache;
cacheDataAdapter.OnBlockAllocated = this.evictionStrategy.OnBlockAllocated;
this.cachePressureMonitor = new AggregatedCachePressureMonitor(logger);
}
/// <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);
}
public PooledQueueCache(ICacheDataAdapter <TQueueMessage, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer)
{
if (cacheDataAdapter == null)
{
throw new ArgumentNullException("cacheDataAdapter");
}
if (comparer == null)
{
throw new ArgumentNullException("comparer");
}
this.cacheDataAdapter = cacheDataAdapter;
this.comparer = comparer;
pool = new CachedMessagePool <TQueueMessage, TCachedMessage>(cacheDataAdapter);
purgeQueue = new ConcurrentQueue <IDisposable>();
messageBlocks = new LinkedList <CachedMessageBlock <TCachedMessage> >();
}
/// <summary>
/// Tries to get the next message from the provided stream, starting at the start index.
/// </summary>
/// <param name="start"></param>
/// <param name="streamIdentity"></param>
/// <param name="comparer"></param>
/// <param name="index"></param>
/// <returns></returns>
public bool TryFindNextMessage(int start, IStreamIdentity streamIdentity, ICacheDataComparer <TCachedMessage> comparer, out int index)
{
if (start < readIndex)
{
throw new ArgumentOutOfRangeException("start");
}
for (int i = start; i < writeIndex; i++)
{
if (comparer.Equals(cachedMessages[i], streamIdentity))
{
index = i;
return(true);
}
}
index = writeIndex - 1;
return(false);
}
/// <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>
public PooledQueueCache(ICacheDataAdapter <TQueueMessage, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer, Logger logger)
{
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", "-");
pool = new CachedMessagePool <TQueueMessage, TCachedMessage>(cacheDataAdapter);
messageBlocks = new LinkedList <CachedMessageBlock <TCachedMessage> >();
}
/// <summary>
/// Compare a cached message with a sequence token to determine if it message is before or after the token
/// </summary>
/// <param name="cachedMessage"></param>
/// <param name="comparer"></param>
/// <param name="streamToken"></param>
/// <returns></returns>
public static int Compare <TCachedMessage>(this ICacheDataComparer <TCachedMessage> comparer, StreamSequenceToken streamToken, TCachedMessage cachedMessage)
{
return(0 - comparer.Compare(cachedMessage, streamToken));
}
/// <summary>
/// Checks to see if the cached message is part of the provided stream
/// </summary>
/// <param name="cachedMessage"></param>
/// <param name="comparer"></param>
/// <param name="streamIdentity"></param>
/// <returns></returns>
public static bool Equals <TCachedMessage>(this ICacheDataComparer <TCachedMessage> comparer, IStreamIdentity streamIdentity, TCachedMessage cachedMessage)
{
return(comparer.Equals(cachedMessage, streamIdentity));
}
public static int Compare <TCachedMessage>(this ICacheDataComparer <TCachedMessage> comparer, IStreamIdentity streamIdentity, TCachedMessage cachedMessage)
{
return(0 - comparer.Compare(cachedMessage, streamIdentity));
}
/// <summary>
/// Tries to find the first message in the block that is part of the provided stream.
/// </summary>
/// <param name="streamIdentity"></param>
/// <param name="comparer"></param>
/// <param name="index"></param>
/// <returns></returns>
public bool TryFindFirstMessage(IStreamIdentity streamIdentity, ICacheDataComparer <TCachedMessage> comparer, out int index)
{
return(TryFindNextMessage(readIndex, streamIdentity, comparer, out index));
}
/// <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>
protected EventHubQueueCache(int defaultMaxAddCount, IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer, Logger logger)
{
this.defaultMaxAddCount = defaultMaxAddCount;
Checkpointer = checkpointer;
cache = new PooledQueueCache <EventData, TCachedMessage>(cacheDataAdapter, comparer, logger);
cacheDataAdapter.PurgeAction = cache.Purge;
cache.OnPurged = OnPurge;
this.cachePressureMonitor = new AggregatedCachePressureMonitor(logger);
}
public EventHubQueueCacheForTesting(IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, CachedEventHubMessage> cacheDataAdapter,
ICacheDataComparer <CachedEventHubMessage> comparer, Logger logger, IEvictionStrategy <CachedEventHubMessage> evictionStrategy)
: base(checkpointer, cacheDataAdapter, comparer, logger, evictionStrategy)
{
}
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)
{
}
/// <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="flowControlThreshold">percentage of unprocesses cache that triggers flow control</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>
protected EventHubQueueCache(int defaultMaxAddCount, double flowControlThreshold, IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer, Logger logger)
{
this.defaultMaxAddCount = defaultMaxAddCount;
Checkpointer = checkpointer;
cache = new PooledQueueCache <EventData, TCachedMessage>(cacheDataAdapter, comparer, logger);
cacheDataAdapter.PurgeAction = cache.Purge;
cache.OnPurged = OnPurge;
cachePressureMonitor = new AveragingCachePressureMonitor(flowControlThreshold, logger);
}
/// <summary>
/// Gets the index of the first message in this block that has a sequence token at or before the provided token
/// </summary>
/// <param name="token"></param>
/// <param name="comparer"></param>
/// <returns></returns>
public int GetIndexOfFirstMessageLessThanOrEqualTo(StreamSequenceToken token, ICacheDataComparer <TCachedMessage> comparer)
{
for (int i = writeIndex - 1; i >= readIndex; i--)
{
if (comparer.Compare(cachedMessages[i], token) <= 0)
{
return(i);
}
}
throw new ArgumentOutOfRangeException("token");
}
protected EventHubQueueCache(IStreamQueueCheckpointer <string> checkpointer, ICacheDataAdapter <EventData, TCachedMessage> cacheDataAdapter, ICacheDataComparer <TCachedMessage> comparer)
: base(cacheDataAdapter, comparer)
{
cacheDataAdapter.PurgeAction = Purge;
Checkpointer = checkpointer;
OnPurged = CheckpointOnPurged;
}
