public IEnumerable <EventBase> ReadAllEvents()
{
IEnumerable <EventBase> CreateEnumerable()
{
var files =
string.IsNullOrWhiteSpace(EventFile)
? from file in _journalDirectoryProvider.FindJournalDirectory().Result.GetFiles("Journal.*.log")
orderby file.Name descending
select file
: new[] { new FileInfo(EventFile), new FileInfo(EventFile) }.AsEnumerable();
foreach (var file in files.Skip(1))
{
using var fileReader =
File.Open(file.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
using var sr = new StreamReader(fileReader);
var lines = new List <string>();
while (!sr.EndOfStream)
{
lines.Add(sr.ReadLine() !);
}
lines.Reverse();
foreach (var line in lines)
{
EventBase?ev = null;
try
{
ev = _eventProvider.ProcessJsonEvent(line).Result;
}
catch (EventNotImplementedException err)
{
}
if (ev != null)
{
yield return(ev);
}
}
}
}
return(new EnumerableStream <EventBase>(CreateEnumerable()));
}
private async void _journalProcessor_NewJournalEntry(object sender, JournalEntry e)
{
try
{
var eventBase = await _eventProvider.ProcessJsonEvent(e.Json);
foreach (var eventProcessor in _eventProcessors)
{
await eventProcessor.InvokeHandler(eventBase, e.IsWhileCatchingUp);
}
}
catch (Exception ex)
{
_log.LogWarning(ex, "Could not execute event for '{Name}'", e.Json);
}
}
internal async Task Run(string path)
{
if (string.IsNullOrWhiteSpace(path))
{
path = "../../../Journal";
}
if (!Directory.Exists(path))
{
_log.LogError(new DirectoryNotFoundException(path), "Directory does not exist");
Environment.Exit(-1);
return;
}
var directory = new DirectoryInfo(path);
var versions = directory.GetDirectories();
IList <Result> results = new List <Result>();
foreach (var versionDirectory in versions)
{
var version = versionDirectory.Name;
var files = versionDirectory.GetFiles();
_log.LogInformation($"Processing v{version}");
IList <Task> tasks = new List <Task>();
var finished = 0;
var total = files.Length;
foreach (var fileInfo in files)
{
tasks.Add(Task.Run(async() =>
{
_log.LogDebug($"Processing {fileInfo.Name}");
var eventName = fileInfo.Name.Replace(".json", " event");
IList <string> allEvents = (await File.ReadAllLinesAsync(fileInfo.FullName)).ToList();
IList <string> testEvents = allEvents.ToList().OrderBy(x => Guid.NewGuid())
.Take(Math.Min(allEvents.Count, 250)).ToList();
total += testEvents.Count();
var hasHadError = false;
for (var i = 1; i < testEvents.Count() + 1; i++)
{
var json = testEvents[i - 1];
try
{
await _eventProvider.ProcessJsonEvent(json);
}
catch (Exception ex)
{
if (hasHadError)
{
continue;
}
hasHadError = true;
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
if (ex == null)
{
continue;
}
var message = new StringBuilder();
message.AppendLine(ex.Message);
var innerException = ex.InnerException;
while (innerException != null)
{
message.AppendLine();
message.AppendLine(innerException.Message);
innerException = innerException.InnerException;
}
results.Add(new Result
{
Title = $"{eventName} (v{version})",
Message = message.ToString(),
Path = Path.Combine(fileInfo.Directory.Name, fileInfo.Name),
Line = allEvents.IndexOf(json) + 1,
Level = "warning"
});
}
}
finished++;
}
}));
}
Task.WaitAll(tasks.ToArray());
}
await File.WriteAllTextAsync("annotations.json", JsonConvert.SerializeObject(results));
var file = new FileInfo("annotations.json");
_log.LogInformation($"Written {results.Count} annotations to {file.FullName}");
}
