public RollingMemoryReadStream(IReadStreamQueueSource sourceQueue,
IReadStreamQueueRefresher readStreamQueueRefresher,
ICompletedReadStreamHandler completedReadStreamHandler,
IRollingMemoryStateMonitor rollingMemoryStateMonitor)
{
_sourceQueue = sourceQueue;
_readStreamQueueRefresher = readStreamQueueRefresher;
_completedReadStreamHandler = completedReadStreamHandler;
_rollingMemoryStateMonitor = rollingMemoryStateMonitor;
}
public RollingMemory(
IWriteStreamFactory writeStreamFactory,
IWriteStreamToReadStreamConverter writeStreamToReadStreamConverter,
IStreamDataSourceDisposerFactory writeStreamDataSourceDisposerFactory,
IStreamDataSourceDisposerFactory readStreamDataSourceDisposerFactory,
IRollingMemoryStateMonitor rollingMemoryStateMonitor,
long? maximumAllowedWriteStreamBytes, TimeSpan? maximumAllowedUnavailableAge,
long? maximumAllowedUnavailableBytes, ICurrentDateTimeSource currentDateTimeSource)
{
var readStreamQueue = new ReadStreamQueue();
var dataSourceDisposerRegister = new DataSourceDisposerRegister();
var completedWriteStreamBuffer = new CompletedWriteStreamBuffer(
readStreamQueue,
writeStreamToReadStreamConverter,
readStreamDataSourceDisposerFactory,
dataSourceDisposerRegister,
maximumAllowedWriteStreamBytes);
var rollingMemoryWriteStream = new RollingMemoryWriteStream(
writeStreamFactory,
completedWriteStreamBuffer,
completedWriteStreamBuffer,
currentDateTimeSource,
writeStreamDataSourceDisposerFactory,
dataSourceDisposerRegister,
rollingMemoryStateMonitor);
var readStreamQueueRefresher = new ReadStreamQueueRefresher(
rollingMemoryWriteStream,
completedWriteStreamBuffer,
maximumAllowedUnavailableAge,
maximumAllowedUnavailableBytes);
var completedReadStreamHandler = new CompletedReadStreamHandler(
dataSourceDisposerRegister);
var rollingMemoryReadStream = new RollingMemoryReadStream(
readStreamQueue,
readStreamQueueRefresher,
completedReadStreamHandler,
rollingMemoryStateMonitor);
_readStream = rollingMemoryReadStream;
_writeStream = rollingMemoryWriteStream;
_completedWriteStreamBuffer = completedWriteStreamBuffer;
}
public BlockingWriteRollingMemory(Func<IRollingMemoryStateMonitor, IRollingMemory> targetFactory,
IRollingMemoryStateMonitor rollingMemoryStateMonitor,
long blockWritesAboveLagBytes)
{
var lagCountingRollingMemoryStateMonitor = new LagCountingRollingMemoryStateMonitor();
rollingMemoryStateMonitor = new CompositeRollingMemoryStateMonitor(rollingMemoryStateMonitor, lagCountingRollingMemoryStateMonitor);
_target = targetFactory(rollingMemoryStateMonitor);
_writeStream = new BlockForCapacityWriteStream(
_target.WriteStream,
() => blockWritesAboveLagBytes - lagCountingRollingMemoryStateMonitor.Lag,
lagCountingRollingMemoryStateMonitor.WaitForLagChange,
lagCountingRollingMemoryStateMonitor.AcquireLagChangeLock,
lagCountingRollingMemoryStateMonitor.ReleaseLagChangeLock
);
}
public RollingMemoryWriteStream(IWriteStreamFactory targetFactory,
ICompletedWriteStreamHandler completedWriteStreamHandler,
IWriteStreamLengthValidator activeWriteStreamLengthValidator,
ICurrentDateTimeSource currentDateTimeSource,
IStreamDataSourceDisposerFactory writeStreamDataSourceDisposerFactory,
IDataSourceDisposerRegister dataSourceDisposerRegister,
IRollingMemoryStateMonitor rollingMemoryStateMonitor)
{
_targetFactory = targetFactory;
_completedWriteStreamHandler = completedWriteStreamHandler;
_activeWriteStreamLengthValidator = activeWriteStreamLengthValidator;
_currentDateTimeSource = currentDateTimeSource;
_writeStreamDataSourceDisposerFactory = writeStreamDataSourceDisposerFactory;
_dataSourceDisposerRegister = dataSourceDisposerRegister;
_rollingMemoryStateMonitor = rollingMemoryStateMonitor;
}
private IRollingMemory BuildCoreRollingMemory(IRollingMemoryStateMonitor rollingMemoryStateMonitor)
{
return new RollingMemory(
WriteStreamFactory,
WriteStreamToReadStreamConverter,
WriteStreamDataSourceDisposerFactory,
ReadStreamDataSourceDisposerFactory,
rollingMemoryStateMonitor,
MaximumAllowedWriteStreamBytes,
MaximumAllowedUnavailableAge,
MaximumAllowedUnavailableBytes,
CurrentDateTimeSource
);
}
/// <summary>
/// Allows you to register a monitor which will be continually updated whenever the write position or read position changes.
/// You can use this to monitor the total amount of data written and read. At any given time, the difference between the
/// total written and the total read should be a rough indicator of the amount of data which is currently stored in
/// rolling memory. Each method is individually thread-safe, and both should be lightweight. The default is null,
/// which means no monitoring.
/// </summary>
/// <param name="rollingMemoryStateMonitor"></param>
/// <returns></returns>
public RollingMemoryBuilder SetRollingMemoryStateMonitor(IRollingMemoryStateMonitor rollingMemoryStateMonitor)
{
_rollingMemoryStateMonitor = rollingMemoryStateMonitor;
return this;
}
