public void WhoTests(string logLine, string name, string @class, int level, string title, string race, string guild, string zone, bool isAfk = false, bool isLfg = false)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result, logLine);
var entry = lineEntry as Who;
Assert.IsNotNull(entry);
Assert.AreEqual(name, entry.Character.Name, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(level, entry.Level, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(title, entry.Title, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(@class, entry.Class, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(race, entry.Race, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(guild, entry.Guild, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(level == 0, entry.IsAnonymous, string.Format("Failing line: {0}", logLine));
if (zone == null)
{
Assert.IsNull(entry.Zone, string.Format("Failing line: {0}", logLine));
}
else
{
Assert.AreEqual(zone, entry.Zone.Name, string.Format("Failing line: {0}", logLine));
}
}
} // For user channels, you can cross server chat: "<serverName>.<charName> tells Channel:#, 'blah blah'."
public Chat(LogDatum logLine, string who, string channel, string text, string server, Zone zone = null) : base(logLine, zone)
{
Who = new Character(who);
Channel = channel;
Text = text;
Server = server;
}
private async Task <int> ReadCurrentSetOfFileLinesAsync(StreamReader sr, ChannelWriter <LogDatum> writer)
{
string line;
int sessionCount = 0;
var count = 0;
while ((line = await sr.ReadLineAsync()) != null && !CancelSource.IsCancellationRequested)
{
_rawLineCount++;
sessionCount++;
if (line == String.Empty)
{
continue;
}
count++;
var logLine = new LogDatum(line, _rawLineCount);
writer.TryWrite(logLine);
// Track so we can print debug message in other channels
_lastLineNumber = logLine.LineNumber;
}
if (sessionCount > 0)
{
WriteMessage($"Lines read: {count:N0} / {sessionCount:N0}, {_sw.Elapsed} elapsed");
}
return(count);
}
private static AttackTypeConverter ATConverter = new AttackTypeConverter(); // TODO: DI this
public Attack(LogDatum logLine, string attacker, string defender, string verb, Zone zone = null) : base(logLine, zone)
{
Attacker = new Character(attacker);
Defender = new Character(defender);
Verb = verb;
Type = ATConverter.Convert(Verb);
}
private bool TryParseMercUpkeep(LogDatum logDatum, out ILine lineEntry)
{
var match = RxMercUpkeep.Match(logDatum.LogMessage);
if (!match.Success)
{
lineEntry = null;
return(false);
}
var chargeOrWaive = match.Groups[1].Value;
var plat = int.Parse(match.Groups[2].Value);
var gold = int.Parse(match.Groups[3].Value);
var bayleMark = match.Groups[4].Success ? int.Parse(match.Groups[4].Value) : 0;
decimal cost = plat + gold / 10m;
var waivedCost = 0m;
if (chargeOrWaive == "waived")
{
waivedCost = cost;
cost = 0;
}
lineEntry = new MercenaryUpkeep(logDatum, cost, waivedCost, bayleMark);
return(true);
}
private bool TryParseDamageShield(LogDatum logDatum, out ILine lineEntry)
{
lineEntry = null;
if (EarlyExitDamageShield(logDatum))
{
return(false);
}
var match = RxDamageShield.Match(logDatum.LogMessage);
if (!match.Success)
{
return(false);
}
var attacker = match.Groups[3].Value;
var attackVerb = match.Groups[2].Value;
var defender = match.Groups[1].Value;
var damage = int.Parse(match.Groups[5].Value);
var damageType = match.Groups[6].Value;
var damageBy = match.Groups[4].Value;
string damageQualifier = null;
lineEntry = new Hit(logDatum, YouAre.WhoAreYou(attacker), YouAre.WhoAreYou(defender), YouAre.WhoAreYou(attackVerb), damage, damageType, damageBy, damageQualifier);
return(true);
}
public Hit(LogDatum logLine, string attacker, string defender, string attackVerb, int damage, string damageType, string damageBy, string damageQualifier, Zone zone = null) : base(logLine, attacker, defender, attackVerb, zone)
{
Damage = damage;
DamageType = damageType;
DamageBy = damageBy;
DamageQualifier = damageQualifier;
}
private void ReadLines(string logPath, ChannelWriter <LogDatum> writer)
{
WriteMessage("Reading log file: {0}", logPath);
var sw = Stopwatch.StartNew();
int count = 0;
using (var fs = File.Open(logPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
using (var sr = new StreamReader(fs))
{
string line;
while ((line = sr.ReadLine()) != null)
{
count++;
if (line == String.Empty)
{
continue;
}
var logLine = new LogDatum(line, count);
writer.TryWrite(logLine);
}
}
writer.Complete(); // We won't do this if this is a live file that's still being written to (how do we tell? Do we need to know?)
sw.Stop();
WriteMessage($"Done reading log file. {count,10:N0} lines {sw.Elapsed} elapsed");
}
public void GarbageLineShorterThanDate()
{
var ld = new LogDatum("kqw");
Assert.AreEqual(DateTime.MinValue, ld.LogTime);
Assert.AreEqual("kqw", ld.RawLogLine);
Assert.AreEqual(string.Empty, ld.LogMessage);
}
public void GarbageLineBiggerThanDate()
{
var ld = new LogDatum("kqwh37c8338jasdlfkj3kj43jrkafsdnase");
Assert.AreEqual(DateTime.MinValue, ld.LogTime);
Assert.AreEqual("kqwh37c8338jasdlfkj3kj43jrkafsdnase", ld.RawLogLine);
Assert.AreEqual(string.Empty, ld.LogMessage);
}
public void EmptyLine()
{
var ld = new LogDatum("");
Assert.AreEqual(DateTime.MinValue, ld.LogTime);
Assert.AreEqual(string.Empty, ld.RawLogLine);
Assert.AreEqual(string.Empty, ld.LogMessage);
}
private bool EarlyExit(LogDatum logDatum)
{
if (logDatum.LogMessage.Contains(DamagePhrase))
{
return(false);
}
return(true);
}
private bool EarlyExitDamageShield(LogDatum logDatum)
{
if (logDatum.LogMessage.Contains("non-melee"))
{
return(false);
}
return(true);
}
private bool EarlyExit(LogDatum logDatum)
{
if (logDatum.LogMessage.Contains("healed"))
{
return(false);
}
return(true);
}
public void YouEnteredStanceNotZone(string logLine)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsFalse(result);
Assert.IsNull(lineEntry);
}
public bool TryParse(LogDatum logDatum, out ILine lineEntry)
{
if (TryParseWho(logDatum, out lineEntry))
{
return(true);
}
return(false);
}
[DataRow("[Mon May 27 07:20:04 2019] You have taken 1112 points of damage.")] // Part of Five Point Palm
public void NullHitTests(string logLine)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsFalse(result, logLine);
Assert.IsNull(lineEntry, logLine);
}
public Heal(LogDatum logLine, string healer, string patient, int amount, int maxAmount, string spellName, bool isHot, string qualifier, Zone zone = null) : base(logLine, zone)
{
Healer = new Character(healer);
Patient = new Character(reflexivePronouns.Contains(patient) ? healer : patient);
Amount = amount;
OverAmount = maxAmount;
SpellName = spellName;
isHealOverTime = isHot;
Qualifier = qualifier;
}
private LogDatum TransformLogLineToDatum(RawLogLineInfo lineInfo)
{
_datumLineCount++;
var datum = new LogDatum(lineInfo.LogLine, lineInfo.LineNumber);
if (datum.LineNumber == _lastLineNumber)
{
Log.Verbose($"Log lines transformed into LogDatums: {_datumLineCount:N0}, {_sw.Elapsed} elapsed");
}
return(datum);
}
private ILine TransformDatumToLine(LogDatum datum)
{
_parsedLineCount++;
var line = _parser.ParseLine(datum);
if (line.LogLine.LineNumber == _lastLineNumber)
{
Log.Verbose($"LogDatum's parsed into ILine's: {_parsedLineCount:N0}, {_sw.Elapsed} elapsed");
}
return(line);
}
public void ZoneTets(string logLine, string zoneName)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result);
Assert.IsTrue(lineEntry is Zone);
var entry = lineEntry as Zone;
Assert.AreEqual(zoneName, entry.Name);
}
public void Tests(string logLine, string name, string songName)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result, logLine);
var entry = lineEntry as Song;
Assert.IsNotNull(entry);
Assert.AreEqual(name, entry.Character.Name, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(songName, entry.SongName, string.Format("Failing line: {0}", logLine));
}
public Who(LogDatum logLine, string name, int level, string title, string @class, string race, string guild, bool isAnon, bool isAfk, bool isLfg, Zone zone = null) : base(logLine, zone)
{
Character = new Character(name);
Level = level;
Title = title;
Class = @class;
Race = race;
Guild = guild;
IsAnonymous = isAnon;
IsAfk = isAfk;
IsLfg = isLfg;
}
// [DataRow("something with an apostrophe in it", "wwwww", "ccccc", "zzzzz")]
// [DataRow("somethign with a backtick", "wwwww", "ccccc", "zzzzz")]
// [DataRow("xxxxxx", "wwwww", "ccccc", "zzzzz")]
// Tricky one ... there is no comma before the text body
// [DataRow("[Fri May 16 20:23:45 2003] Sontalak says 'Ack! I must be careful not to step on that body, it tastes much better when it is still crunchy, not pulped!'", "wwwww", "ccccc", "zzzzz")]
public void ChatTests(string logLine, string whoName, string channel, string text)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result);
Assert.IsTrue(lineEntry is Chat);
var entry = lineEntry as Chat;
Assert.AreEqual(whoName, entry.Who.Name);
Assert.AreEqual(channel, entry.Channel);
Assert.AreEqual(text, entry.Text);
}
private void ParseLine(LogDatum logLine, ChannelWriter <ILine> writer)
{
_parsedLineCount++;
var line = _parser.ParseLine(logLine);
writer.TryWrite(line);
// if (_parsedLineCount % 10000 == 0)
// WriteMessage($"Lines parsed: {_parsedLineCount:N0}, {_sw.Elapsed} elapsed");
if (line.LogLine.LineNumber == _lastLineNumber)
{
WriteMessage($"Lines parsed: {_parsedLineCount:N0}, {_sw.Elapsed} elapsed");
}
}
public void Tests(string logLine, string attacker, string defender, string verb, AttackType attackType, bool isDefenderPet = false)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result, logLine, string.Format("Failing line: {0}", logLine));
var entry = lineEntry as Kill;
Assert.IsNotNull(entry, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(attacker, entry.Attacker.Name, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(isDefenderPet, entry.Defender.IsPet, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(defender, entry.Defender.Name, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(verb, entry.Verb, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(attackType, entry.Type, string.Format("Failing line: {0}", logLine));
}
private bool TryParseZone(LogDatum logDatum, out ILine lineEntry)
{
var match = RxZone.Match(logDatum.LogMessage);
if (!match.Success)
{
lineEntry = null;
return(false);
}
var zoneName = match.Groups[1].Value;
lineEntry = new Zone(logDatum, zoneName);
return(true);
}
public void SpellDamage(string logLine, string attacker, int damage, string verb, string by, string spellTarget)
{
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result, logLine);
Assert.IsTrue(lineEntry is Hit, logLine);
var hitEntry = lineEntry as Hit;
Assert.AreEqual(attacker, hitEntry.Attacker.Name, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(damage, hitEntry.Damage, string.Format("Failing line: {0}", logLine));
// Assert.AreEqual(verb, hitEntry.Verb, string.Format("Failing line: {0}", logLine));
// Assert.AreEqual(by, hitEntry.By, string.Format("Failing line: {0}", logLine));
// Assert.AreEqual(spellTarget, hitEntry.xxx, string.Format("Failing line: {0}", logLine));
}
public void Tests(string logLine, string pszCost, string pszWaivedCost, int bayleMarks)
{
var cost = decimal.Parse(pszCost);
var waivedCost = decimal.Parse(pszWaivedCost);
var logDatum = new LogDatum(logLine);
var result = _parser.TryParse(logDatum, out ILine lineEntry);
Assert.IsTrue(result, logLine);
var entry = lineEntry as MercenaryUpkeep;
Assert.IsNotNull(entry);
Assert.AreEqual(cost, entry.Cost, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(waivedCost, entry.WaivedCost, string.Format("Failing line: {0}", logLine));
Assert.AreEqual(bayleMarks, entry.BayleMarks, string.Format("Failing line: {0}", logLine));
}
private bool TryParseSpell(LogDatum logDatum, out ILine lineEntry)
{
var match = RxSpell.Match(logDatum.LogMessage);
if (!match.Success)
{
lineEntry = null;
return(false);
}
var name = match.Groups[1].Value;
var spellName = match.Groups[2].Value;
lineEntry = new Spell(logDatum, YouAre.WhoAreYou(name), spellName);
return(true);
}
