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