test changes

Author: BRUNER Patrick

src/tools/LogRotator/LogRotator.cs

@@ -35,16 +35,31 @@
 Console.WriteLine($"Control characters in output: {(includeControlChars ? "ENABLED" : "disabled")}");
 Console.WriteLine("Press ENTER to perform a rotation (with oldest file deletion).");
 Console.WriteLine("Press A to append a single live line (no rotation) for tail testing.");
+Console.WriteLine("Press D to delete the log, wait, then recreate it AND start a 25 lines/s");
+Console.WriteLine("  background writer (repro for issue #568). Press D again to delete mid-stream.");
+Console.WriteLine("Press F to flicker: delete, wait, briefly recreate, delete again mid-reload,");
+Console.WriteLine("  wait, then recreate + writer. Tries to land LogExpert's new reader's");
+Console.WriteLine("  ReadFiles inside a deletion window.");
 Console.WriteLine("Press Q to quit.");
 
 var rotationCount = 0;
+var delayedDeleteCount = 0;
+var flickerCount = 0;
+const int delayedDeleteSeconds = 5;
+const int liveWriterDelayMs = 40; // ~25 lines/s
+const int flickerInitialAbsentMs = 5000;
+const int flickerBriefVisibleMs = 200;
+const int flickerSecondAbsentMs = 2500;
+CancellationTokenSource? liveWriterCts = null;
+Task? liveWriterTask = null;
 
 while (true)
 {
     var key = Console.ReadKey(true);
 
     if (key.Key == ConsoleKey.Q)
     {
+        StopLiveWriter();
         break;
     }
 
@@ -54,6 +69,20 @@
         continue;
     }
 
+    if (key.Key == ConsoleKey.D)
+    {
+        delayedDeleteCount++;
+        DelayedDelete(Path.Join(baseDir, safeBaseName), delayedDeleteCount, delayedDeleteSeconds);
+        continue;
+    }
+
+    if (key.Key == ConsoleKey.F)
+    {
+        flickerCount++;
+        FlickerRepro(Path.Join(baseDir, safeBaseName), flickerCount);
+        continue;
+    }
+
     if (key.Key != ConsoleKey.Enter)
     {
         continue;
@@ -131,6 +160,149 @@ void AppendLiveLine(string path)
     Console.WriteLine($"  Appended live line to {name} ({new FileInfo(path).Length} bytes total)");
 }
 
+// Repro path for issue #568: stop any background writer, delete the file and
+// keep it absent long enough (> LogExpert's 1.25s OpenStream retry budget) for
+// the watcher to enter FileNotFound state, then recreate it AND start a
+// continuous background writer (~25 lines/s). The next D press will delete the
+// file while the writer is actively appending — that mid-stream delete is the
+// scenario the reporter describes.
+void DelayedDelete(string path, int iteration, int delaySeconds)
+{
+    var name = Path.GetFileName(path);
+    Console.WriteLine($"\n--- Delete + delay + recreate #{iteration} ---");
+
+    StopLiveWriter();
+
+    if (File.Exists(path))
+    {
+        File.Delete(path);
+        Console.WriteLine($"  Deleted: {name}");
+    }
+    else
+    {
+        Console.WriteLine($"  {name} was already missing.");
+    }
+
+    Console.WriteLine($"  File absent. Waiting {delaySeconds}s so LogExpert enters FileNotFound state...");
+    for (var i = delaySeconds; i > 0; i--)
+    {
+        Console.Write($"\r  Countdown: {i}s ");
+        Thread.Sleep(1000);
+    }
+    Console.WriteLine("\r  Countdown: done.");
+
+    WriteLogFile(path, fileId: 900 + iteration);
+    Console.WriteLine($"  Recreated {name} with {linesPerFile} lines ({new FileInfo(path).Length} bytes).");
+    StartLiveWriter(path, iteration);
+    Console.WriteLine($"  Background writer started (~{1000 / liveWriterDelayMs} lines/s).");
+    Console.WriteLine("  Watch LogExpert: lines should keep appearing.");
+    Console.WriteLine("  If they do NOT, the bug is reproduced. Press D again to delete mid-stream.");
+}
+
+// Tighter race than DelayedDelete: after the file has been absent long enough
+// for LogExpert to enter FileNotFound, we briefly recreate it (so the watcher
+// fires OnRespawned and the LogWindow schedules a Reload), then delete it
+// again before the new LogfileReader's first ReadFiles completes its
+// OpenStream retries (5 x 250ms = 1.25s). If the hypothesis about issue #568
+// is correct, the new reader's ReadFiles catches IOException, _isDeleted is
+// set, ReportLoadingFinished is skipped, and FileSizeChanged never gets wired
+// up. After we recreate the file for real and start the writer, those writes
+// should fail to propagate.
+void FlickerRepro(string path, int iteration)
+{
+    var name = Path.GetFileName(path);
+    Console.WriteLine($"\n--- Flicker repro #{iteration} ---");
+
+    StopLiveWriter();
+
+    if (File.Exists(path))
+    {
+        File.Delete(path);
+        Console.WriteLine($"  Deleted: {name}");
+    }
+
+    Console.WriteLine($"  Phase 1: file absent for {flickerInitialAbsentMs / 1000.0:0.0}s (LogExpert -> FileNotFound)");
+    Thread.Sleep(flickerInitialAbsentMs);
+
+    WriteLogFile(path, fileId: 700 + iteration);
+    Console.WriteLine($"  Phase 2: briefly visible ({flickerBriefVisibleMs}ms) - LogExpert schedules a Reload");
+    Thread.Sleep(flickerBriefVisibleMs);
+
+    File.Delete(path);
+    Console.WriteLine($"  Phase 3: deleted again, absent {flickerSecondAbsentMs / 1000.0:0.0}s");
+    Console.WriteLine($"           (exceeds 1.25s OpenStream retry budget - new reader's ReadFiles should fail)");
+    Thread.Sleep(flickerSecondAbsentMs);
+
+    WriteLogFile(path, fileId: 750 + iteration);
+    Console.WriteLine($"  Phase 4: recreated with {linesPerFile} lines, starting writer.");
+    StartLiveWriter(path, iteration);
+    Console.WriteLine("  Watch LogExpert. If row count freezes, bug reproduced.");
+}
+
+void StartLiveWriter(string path, int iteration)
+{
+    StopLiveWriter();
+    liveWriterCts = new CancellationTokenSource();
+    var token = liveWriterCts.Token;
+    var fileId = 800 + iteration;
+    liveWriterTask = Task.Run(() => LiveWriterLoop(path, fileId, token));
+}
+
+void StopLiveWriter()
+{
+    if (liveWriterCts == null)
+    {
+        return;
+    }
+
+    liveWriterCts.Cancel();
+    try
+    {
+        liveWriterTask?.Wait(TimeSpan.FromSeconds(2));
+    }
+    catch (AggregateException)
+    {
+        // expected: task cancelled
+    }
+
+    liveWriterCts.Dispose();
+    liveWriterCts = null;
+    liveWriterTask = null;
+}
+
+void LiveWriterLoop(string path, int fileId, CancellationToken token)
+{
+    var name = Path.GetFileName(path);
+    var lineIndex = 0;
+    while (!token.IsCancellationRequested)
+    {
+        try
+        {
+            using var fs = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete);
+            using var writer = new StreamWriter(fs, Encoding.UTF8);
+            writer.WriteLine(BuildLine(fileId, ++lineIndex, name));
+        }
+        catch (IOException)
+        {
+            // file may be momentarily inaccessible during a D-press; just keep
+            // trying so writes resume once it reappears.
+        }
+
+        try
+        {
+            Task.Delay(liveWriterDelayMs, token).Wait(token);
+        }
+        catch (OperationCanceledException)
+        {
+            return;
+        }
+        catch (AggregateException)
+        {
+            return;
+        }
+    }
+}
+
 string BuildLine(int fileId, int lineIndex, string fileName)
 {
     var baseText = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} [INFO] File#{fileId:D3} Line {lineIndex:D3} - {fileName} - Sample log message";