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; } }