protected virtual void LogPackage <T>(PPPokerPackage package)
{
try
{
if (package.PackageType == PackageType.HeartBeatREQ || package.PackageType == PackageType.HeartBeatRSP)
{
return;
}
if (!SerializationHelper.TryDeserialize(package.Body, out T packageContent))
{
LogProvider.Log.Warn(Logger, $"Failed to deserialize {typeof(T)} package");
}
var packageJson = new PackageJson <T>
{
PackageType = package.PackageType,
Direction = package.Direction,
ClientPort = package.ClientPort,
Content = packageContent,
Time = package.Timestamp
};
var json = JsonConvert.SerializeObject(packageJson, Formatting.Indented, new StringEnumConverter());
//protectedLogger.Log(json);
LogProvider.Log.Info(json);
}
catch (Exception e)
{
LogProvider.Log.Error(Logger, "Failed to log package", e);
}
}
private void AssertPackage <T>(PPPokerPackage package, CapturedPacket capturedPacket)
{
Assert.IsTrue(
SerializationHelper.TryDeserialize(package.Body, out T packageContent),
$"Failed to deserialize {typeof(T)} package [ticks={capturedPacket.CreatedTimeStamp.Ticks}, userid={package.ClientPort}]"
);
}
protected virtual void LogPackage(PPPokerPackage package)
{
if (LogPackageMapping.ContainsKey(package.PackageType))
{
LogPackageMapping[package.PackageType].Invoke(this, new object[] { package });
}
}
/// <summary>
/// Checks whenever the specified package has to be processed
/// </summary>
/// <param name="package">Package to check</param>
/// <returns></returns>
protected static bool IsAllowedPackage(PPPokerPackage package)
{
switch (package.PackageType)
{
case PackageType.GetUserMarksREQ:
case PackageType.GetUserMarksRSP:
case PackageType.SelUserInfoRSP:
case PackageType.EnterRoomRSP:
case PackageType.SitDownRSP:
case PackageType.SitDownBRC:
case PackageType.StandUpBRC:
case PackageType.BlindStatusBRC:
case PackageType.DealerInfoRSP:
case PackageType.RoundStartBRC:
case PackageType.RoundOverBRC:
case PackageType.ActionBRC:
case PackageType.HandCardRSP:
case PackageType.ShowHandRSP:
case PackageType.WinnerRSP:
case PackageType.ShowMyCardBRC:
case PackageType.UserSngOverRSP:
case PackageType.TableGameOverRSP:
case PackageType.LeaveRoomRSP:
return(true);
default:
return(false);
}
}
private void ParsePackage <T>(PPPokerPackage package, Action <T> action)
{
if (!SerializationHelper.TryDeserialize(package.Body, out T packageBody))
{
//throw new DHInternalException(new NonLocalizableString($"Failed to deserialize package of {package.PackageType} type."));
throw new Exception($"Failed to deserialize package of {package.PackageType} type.");
}
action?.Invoke(packageBody);
}
public void LogPackage(CapturedPacket capturedPacket, PPPokerPackage package)
{
if (!loggers.TryGetValue(package.ClientPort, out DebugPPPLogger logger))
{
logger = new DebugPPPLogger(package.ClientPort);
loggers.Add(package.ClientPort, logger);
}
protectedLogger = logger;
base.LogPackage(package);
}
/// <summary>
/// Parses package body into the specified type <see cref="{T}"/>, then performs <paramref name="onSuccess"/> if parsing succeed,
/// or <paramref name="onFail"/> if parsing failed
/// </summary>
/// <typeparam name="T">Type of the package body</typeparam>
/// <param name="package">Package to parse</param>
/// <param name="onSuccess">Action to perform if parsing succeed</param>
/// <param name="onFail">Action to perform if parsing failed</param>
protected virtual void ParsePackage <T>(PPPokerPackage package, Action <T> onSuccess, Action onFail)
{
if (SerializationHelper.TryDeserialize(package.Body, out T packageBody))
{
onSuccess?.Invoke(packageBody);
return;
}
LogProvider.Log.Warn(Logger, $"Failed to deserialize {typeof(T)} package");
onFail?.Invoke();
}
protected virtual void LogPackage <T>(PPPokerPackage package)
{
try
{
if (package.PackageType == PackageType.HeartBeatREQ || package.PackageType == PackageType.HeartBeatRSP)
{
return;
}
#if DEBUG
if (!SerializationHelper.TryDeserialize(package.Body, out T packageContent))
{
LogProvider.Log.Warn(this, $"Failed to deserialize {typeof(T)} package");
}
var packageJson = new PackageJson <T>
{
PackageType = package.PackageType,
Direction = package.Direction,
ClientPort = package.ClientPort,
Content = packageContent,
Time = package.Timestamp
};
var json = JsonConvert.SerializeObject(packageJson, Formatting.Indented, new StringEnumConverter());
protectedLogger.Log(json);
#else
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, package);
var packageBytes = ms.ToArray();
var logText = Encoding.UTF8.GetString(packageBytes);
protectedLogger.Log(logText);
}
#endif
}
catch (Exception e)
{
LogProvider.Log.Error(this, "Failed to log package", e);
}
}
private PPPokerPackage BuildPackage <T>(PPPTestSourcePacket packet)
{
var contentObject = JsonConvert.DeserializeObject <T>(packet.Content.ToString(), new StringEnumConverter());
Assert.IsNotNull(contentObject, $"Content object of {typeof(T)} must be not null.");
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, contentObject);
var bytes = ms.ToArray();
var package = new PPPokerPackage
{
PackageType = packet.PackageType,
Body = bytes,
Timestamp = packet.Time
};
return(package);
}
}
private IEnumerable <PPPokerPackage> ReadPackages(string folder)
{
var packages = new List <PPPokerPackage>();
var jsonFile = Path.Combine(TestDataFolder, folder, SourceJsonFile);
FileAssert.Exists(jsonFile);
PPPTestSourceObject testSourceObject = null;
try
{
var jsonFileContent = File.ReadAllText(jsonFile);
testSourceObject = JsonConvert.DeserializeObject <PPPTestSourceObject>(jsonFileContent, new StringEnumConverter());
}
catch (Exception e)
{
Assert.Fail($"{ExpectedResultFile} in {folder} has not been deserialized: {e}");
}
Assert.IsNotNull(testSourceObject);
foreach (var packet in testSourceObject.Packets)
{
PPPokerPackage package = null;
if (BuildPackageMapping.ContainsKey(packet.PackageType))
{
package = (PPPokerPackage)BuildPackageMapping[packet.PackageType].Invoke(this, new object[] { packet });
}
Assert.IsNotNull(package);
packages.Add(package);
}
return(packages);
}
public bool TryBuild(PPPokerPackage package, out HandHistory handHistory)
{
handHistory = null;
if (package == null)
{
return(false);
}
if (!clientRecords.TryGetValue(package.ClientPort, out ClientRecord record))
{
record = clientRecords[package.ClientPort] = new ClientRecord {
Port = package.ClientPort
};
}
if (package.PackageType == PackageType.EnterRoomRSP)
{
ParsePackage <EnterRoomRSP>(package, m => ProcessEnterRoomRSP(m, record));
return(false);
}
// We use both GetUserMarksREQ and GetUserMarksRSP to get Uid and to be sure that no packets are lost and we successfully determined who is hero
else if (package.PackageType == PackageType.GetUserMarksREQ)
{
ParsePackage <GetUserMarksREQ>(package, m => ProcessGetUserMarksREQ(m, record));
}
else if (package.PackageType == PackageType.GetUserMarksRSP)
{
ParsePackage <GetUserMarksRSP>(package, m => ProcessGetUserMarksRSP(m, record));
}
// Delay following actions until DealerInfoRSP message arrives
// Otherwise these messages will not be processed becase ValidatePackages in BuildHand method will return false and package list will be cleared
if (package.PackageType == PackageType.SelUserInfoRSP)
{
record.DelayedActions.Add(() => ParsePackage <SelUserInfoRSP>(package, m => ProcessSelUserInfoRSP(m, record)));
}
else if (package.PackageType == PackageType.SitDownRSP)
{
record.DelayedActions.Add(() => ParsePackage <SitDownRSP>(package, m => ProcessSitDownRSP(m, record)));
}
else if (package.PackageType == PackageType.BlindStatusBRC)
{
record.DelayedActions.Add(() => ParsePackage <BlindStatusBRC>(package, m => ProcessBlindStatusBRC(m, record)));
}
else if (package.PackageType == PackageType.SitDownBRC)
{
record.DelayedActions.Add(() => ParsePackage <SitDownBRC>(package, m => ProcessSitDownBRC(m, record)));
}
else if (package.PackageType == PackageType.StandUpBRC)
{
record.DelayedActions.Add(() => ParsePackage <StandUpBRC>(package, m => ProcessStandUpBRC(m, record)));
}
if (package.PackageType == PackageType.DealerInfoRSP || record.IsHandStarted && TerminatingPackageTypes.Contains(package.PackageType))
{
handHistory = BuildHand(record);
if (record.DelayedActions.Count > 0)
{
foreach (var action in record.DelayedActions)
{
action();
}
record.DelayedActions.Clear();
}
record.IsHandStarted = false;
}
record.Packages.Add(package);
if (package.PackageType == PackageType.DealerInfoRSP)
{
record.IsHandStarted = true;
}
return(handHistory != null);
}
public bool IsRoomSnapShotAvailable(PPPokerPackage package)
{
return(clientRecords.TryGetValue(package.ClientPort, out ClientRecord record) && record.RoomID != 0);
}
public new void ParsePackage <T>(PPPokerPackage package, Action <T> onSuccess, Action onFail)
{
base.ParsePackage(package, onSuccess, onFail);
}
public new static bool IsAllowedPackage(PPPokerPackage package)
{
return(PPPImporter.IsAllowedPackage(package));
}
private void AssertPackage(PPPokerPackage package, CapturedPacket capturedPacket)
{
switch (package.PackageType)
{
case PackageType.GetUserMarksREQ:
AssertPackage <GetUserMarksREQ>(package, capturedPacket);
break;
case PackageType.GetUserMarksRSP:
AssertPackage <GetUserMarksRSP>(package, capturedPacket);
break;
case PackageType.SelUserInfoRSP:
AssertPackage <SelUserInfoRSP>(package, capturedPacket);
break;
case PackageType.EnterRoomRSP:
AssertPackage <EnterRoomRSP>(package, capturedPacket);
break;
case PackageType.SitDownRSP:
AssertPackage <SitDownRSP>(package, capturedPacket);
break;
case PackageType.SitDownBRC:
AssertPackage <SitDownBRC>(package, capturedPacket);
break;
case PackageType.StandUpBRC:
AssertPackage <StandUpBRC>(package, capturedPacket);
break;
case PackageType.BlindStatusBRC:
AssertPackage <BlindStatusBRC>(package, capturedPacket);
break;
case PackageType.DealerInfoRSP:
AssertPackage <DealerInfoRSP>(package, capturedPacket);
break;
case PackageType.RoundStartBRC:
AssertPackage <RoundStartBRC>(package, capturedPacket);
break;
case PackageType.RoundOverBRC:
AssertPackage <RoundOverBRC>(package, capturedPacket);
break;
case PackageType.ActionBRC:
AssertPackage <ActionBRC>(package, capturedPacket);
break;
case PackageType.HandCardRSP:
AssertPackage <HandCardRSP>(package, capturedPacket);
break;
case PackageType.ShowHandRSP:
AssertPackage <ShowHandRSP>(package, capturedPacket);
break;
case PackageType.WinnerRSP:
AssertPackage <WinnerRSP>(package, capturedPacket);
break;
case PackageType.ShowMyCardBRC:
AssertPackage <ShowMyCardBRC>(package, capturedPacket);
break;
case PackageType.UserSngOverRSP:
AssertPackage <UserSngOverRSP>(package, capturedPacket);
break;
case PackageType.TableGameOverRSP:
AssertPackage <TableGameOverRSP>(package, capturedPacket);
break;
case PackageType.LeaveRoomRSP:
AssertPackage <LeaveRoomRSP>(package, capturedPacket);
break;
}
}
