public void TryParseTest(string json, Adda52PackageType packageType)
{
var result = Adda52JsonPackage.TryParse(json, out Adda52JsonPackage jsonPackage);
Assert.IsTrue(result);
Assert.That(jsonPackage.PackageType, Is.EqualTo(packageType));
}
public bool TryBuild(Adda52JsonPackage package, out HandHistory handHistory)
{
handHistory = null;
if (package == null)
{
return(false);
}
if (package.PackageType == Adda52PackageType.RoomData)
{
ParsePackage <RoomData>(package, x => ProcessRoomData(package.RoomId, x));
return(false);
}
if (package.PackageType == Adda52PackageType.AccessToken)
{
ParsePackage <AccessToken>(package, x => ProcessAccessToken(x));
return(false);
}
if (package.PackageType == Adda52PackageType.MTTInfo)
{
ParsePackage <MTTInfo>(package, x => ProcessMTTInfo(x));
return(false);
}
if (package.PackageType == Adda52PackageType.MTTTables)
{
ParsePackage <MTTTables>(package, x => ProcessMTTTables(x));
return(false);
}
if (package.PackageType == Adda52PackageType.MTTPrizes)
{
ParsePackage <MTTPrizes>(package, x => ProcessMTTPrizes(x));
return(false);
}
if (!roomPackages.TryGetValue(package.RoomId, out List <Adda52JsonPackage> packages))
{
packages = new List <Adda52JsonPackage>();
roomPackages.Add(package.RoomId, packages);
}
packages.Add(package);
if (package.PackageType == Adda52PackageType.RoundEnd)
{
handHistory = BuildHand(packages);
}
return(handHistory != null && handHistory.Players.Count > 0);
}
private void ParsePackage <T>(Adda52JsonPackage package, Action <T> action) where T : class
{
Adda52Message <T> message;
try
{
message = JsonConvert.DeserializeObject <Adda52Message <T> >(package.JsonData);
}
catch
{
throw new DHInternalException(new NonLocalizableString($"Failed to deserialize package of {package.PackageType} type."));
}
action?.Invoke(message.Body.Data);
}
private IEnumerable <Adda52JsonPackage> ReadPackages(string testFolder)
{
var packages = new List <Adda52JsonPackage>();
var sourceJsonFile = Path.Combine(TestDataFolder, testFolder, SourceJsonFile);
FileAssert.Exists(sourceJsonFile);
var sourceJson = File.ReadAllText(sourceJsonFile);
var testObject = JsonConvert.DeserializeObject <Adda52TestSourceObject>(sourceJson);
foreach (var packet in testObject.Packages)
{
var json = JsonConvert.SerializeObject(packet);
if (Adda52JsonPackage.TryParse(json, out Adda52JsonPackage package))
{
packages.Add(package);
}
}
return(packages);
}
private void LogPackage(Adda52Package package)
{
try
{
if (!Adda52JsonPackage.TryParseJsonData(package.Bytes, out string contentJson))
{
return;
}
var ignoreList = new[] { "game.keepAlive", "game.Message", "game.usercount", "game.avgstack", "game.account" };
if (ignoreList.Any(x => contentJson.Contains(x)))
{
return;
}
#if DEBUG
Console.WriteLine(contentJson);
if (contentJson.Contains("game.started"))
{
protectedLogger.Log("-------------------------------------------------------------------------------------");
}
#endif
protectedLogger.Log(contentJson);
#if DEBUG
if (contentJson.Contains("game.roundend"))
{
protectedLogger.Log("-------------------------------------------------------------------------------------");
}
#endif
}
catch (Exception e)
{
LogProvider.Log.Error(this, $"Failed to log package. [{SiteString}]", e);
}
}
//[TestCase(@"Packets\0.0.0.0.8893-127.0.0.1.12032.txt", @"Packets\NotJsonOnlyPacket.json")]
public void TryParseTest(string file, string expectedResultFile)
{
var packets = ReadCapturedPackets(file, null);
var packetManager = new Adda52PacketManager();
var actualJson = string.Empty;
var expectedJson = JsonConvert.SerializeObject(JsonConvert.DeserializeObject(File.ReadAllText(Path.Combine(TestDataFolder, expectedResultFile))), Formatting.Indented);
var sequenceNumber = 1u;
using (ShimsContext.Create())
{
foreach (var packet in packets)
{
ShimDateTime.NowGet = () => packet.CreatedTimeStamp;
packet.SequenceNumber = sequenceNumber++;
if (packetManager.TryParse(packet, out IList <Adda52Package> packages))
{
var package = packages.FirstOrDefault();
Assert.IsNotNull(package);
Adda52JsonPackage.TryParseJsonData(package.Bytes, out string jsonText);
var dynamicObject = JsonConvert.DeserializeObject(jsonText);
actualJson = JsonConvert.SerializeObject(dynamicObject, Formatting.Indented);
}
}
}
Assert.That(actualJson, Is.EqualTo(expectedJson));
}
/// <summary>
/// Processes packets in the buffer
/// </summary>
protected void ProcessBuffer()
{
var packetManager = ServiceLocator.Current.GetInstance <IPacketManager <Adda52Package> >();
var handBuilder = ServiceLocator.Current.GetInstance <IAdda52HandBuilder>();
var packetManagerFails = 0;
var jsonPackageTryParseFails = 0;
while (!cancellationTokenSource.IsCancellationRequested && !IsDisabled())
{
try
{
if (!packetBuffer.TryTake(out CapturedPacket capturedPacket))
{
Task.Delay(NoDataDelay).Wait();
continue;
}
#if DEBUG
// LogPacket(capturedPacket, ".log");
#endif
if (!packetManager.TryParse(capturedPacket, out IList <Adda52Package> packages))
{
if (IsAdvancedLogEnabled && packetManagerFails < 10)
{
LogProvider.Log.Warn(this, $"Failed to parse packet: '{Convert.ToBase64String(capturedPacket.Bytes)}' [{SiteString}]");
packetManagerFails++;
}
continue;
}
foreach (var package in packages)
{
if (IsAdvancedLogEnabled)
{
LogPackage(package);
}
if (!Adda52JsonPackage.TryParse(package.Bytes, out Adda52JsonPackage jsonPackage))
{
if (IsAdvancedLogEnabled && jsonPackageTryParseFails < 10)
{
LogProvider.Log.Warn(this, $"Failed to parse json from packet: '{Convert.ToBase64String(capturedPacket.Bytes)}' [{SiteString}]");
jsonPackageTryParseFails++;
}
continue;
}
if (!handBuilder.TryBuild(jsonPackage, out HandHistory handHistory))
{
continue;
}
var handHistoryText = SerializationHelper.SerializeObject(handHistory);
#if DEBUG
if (!Directory.Exists("Hands"))
{
Directory.CreateDirectory("Hands");
}
File.WriteAllText($"Hands\\adda52_hand_exported_{handHistory.HandId}.xml", handHistoryText);
#endif
var windowHandle = tableService.GetWindow(handHistory);
var gameInfo = new GameInfo
{
WindowHandle = windowHandle.ToInt32(),
PokerSite = Site,
GameNumber = handHistory.HandId,
Session = windowHandle.ToString()
};
ProcessHand(handHistoryText, gameInfo);
}
}
catch (Exception e)
{
LogProvider.Log.Error(this, $"Failed to process captured packet. [{SiteString}]", e);
}
}
}
