/// <summary> /// Initializes a new instance of the PhysicalLogReader class. /// </summary> /// <param name="logManager">The log manager.</param> /// <param name="startingRecordPosition">Stream position to start reading.</param> /// <param name="endingRecordPosition">Stream position of the start of the last record that will be read.</param> /// <param name="startingLsn">Logical sequence number of the first record.</param> /// <param name="readerName">Name of the reader that will be used in tracing.</param> /// <param name="readerType">Type of the reader.</param> /// <remarks> /// Note that ending record position is INCLUSIVE: the last record will be read. /// Starting logical sequence number is used to decide the when an lsn is safe (will not be undone or redone). /// </remarks> public PhysicalLogReader( LogManager logManager, ulong startingRecordPosition, ulong endingRecordPosition, long startingLsn, string readerName, LogManager.LogReaderType readerType) { this.logManager = logManager; this.readStream = null; this.startingRecordPosition = startingRecordPosition; this.startingLsn = startingLsn; this.endingRecordPosition = endingRecordPosition; Utility.Assert( startingRecordPosition <= endingRecordPosition, "startingRecordPosition <= endingRecordPosition"); this.isValid = logManager.AddLogReader( startingLsn, startingRecordPosition, endingRecordPosition, readerName, readerType); this.isDisposed = false; this.startingRecord = LogRecord.InvalidLogRecord; this.endRecord = LogRecord.InvalidLogRecord; }
public IAsyncEnumerator <LogRecord> GetLogRecords(string readerName, LogManager.LogReaderType readerType) { var logRecords = new LogRecords( this.logManager, this.startingRecordPosition, this.endingRecordPosition, this.startingLsn, readerName, readerType); return(logRecords); }
internal void MoveStartingRecordPosition( long startingLsn, ulong newStartingRecordPosition, string readerName, LogManager.LogReaderType readerType) { if (this.isValid) { var isValid = this.logManager.AddLogReader( startingLsn, newStartingRecordPosition, this.endingRecordPosition, readerName, readerType); Utility.Assert(isValid, "isValid == true"); this.logManager.RemoveLogReader(this.startingRecordPosition); } this.startingRecordPosition = newStartingRecordPosition; this.startingLsn = startingLsn; this.startingRecord = LogRecord.InvalidLogRecord; }
/// <summary> /// Asynchronous enumerator for log records. /// </summary> /// <param name="logManager">The source log manager.</param> /// <param name="enumerationStartingPosition">Inclusive starting position.</param> /// <param name="enumerationEndingPosition">Inclusive ending position: record at this starting position will be read.</param> /// <param name="enumerationStartedAtLsn">Lsn of the first record. Used for determining what record is safe: no redo or undo.</param> /// <param name="readerName">Name of the reader for tracing.</param> /// <param name="readerType">Type of the reader.</param> /// <remarks> /// enumerationStartingPosition and enumerationEndingPosition is inclusive: the last record at enumerationEndingPosition position will be read. /// </remarks> internal LogRecords( LogManager logManager, ulong enumerationStartingPosition, ulong enumerationEndingPosition, long enumerationStartedAtLsn, string readerName, LogManager.LogReaderType readerType) { this.readerName = readerName; this.readerType = readerType; this.logManager = logManager; this.enumerationEndingPosition = enumerationEndingPosition; this.enumerationStartedAtLsn = enumerationStartedAtLsn; this.logManager.AddLogReader( enumerationStartedAtLsn, enumerationStartingPosition, enumerationEndingPosition, readerName, readerType); this.readStream = logManager.CreateReaderStream(); this.Init(enumerationStartingPosition); this.logManager.SetSequentialAccessReadSize(this.readStream, LogManager.ReadAheadBytesForSequentialStream); }