252 lines
8.9 KiB
C#
252 lines
8.9 KiB
C#
using System.Collections.Concurrent;
|
|
|
|
|
|
using Google.Protobuf;
|
|
using NeoSmart.AsyncLock;
|
|
using Nettention.Proud;
|
|
|
|
|
|
using ServerCore; using ServerBase;
|
|
|
|
|
|
namespace ServerBase;
|
|
|
|
public class LargePacketHandler
|
|
{
|
|
//private ConcurrentDictionary<(Player, string), SortedSet<CollectedPacketInfo>> m_large_packets = new();
|
|
private ConcurrentDictionary<IEntityWithSession, SortedSet<CollectedPacketInfo>> m_large_packets = new(); // 하나의 패킷만 처리
|
|
private static AsyncLock _lock = new();
|
|
|
|
private SessionBase? m_network_session { get; set; }
|
|
|
|
public void onInit(SessionBase networkSession)
|
|
{
|
|
m_network_session = networkSession;
|
|
var func = checkLargePacket;
|
|
_ = PeriodicTaskHelper.runTask(func, TimeSpan.FromMilliseconds(Constant.LARGE_PACKET_CHECK_INTERVAL_MSEC));
|
|
}
|
|
|
|
public Result collectPacket(IEntityWithSession ssesion, string packetUid, Int32 totalPacketCount, Int32 packetIdx, ByteString datas)
|
|
{
|
|
Log.getLogger().debug($"LargePacketCollect packetUid : {packetUid}, totalPacketCount : {totalPacketCount}, packetIdx : {packetIdx}, datasize : {datas.Length}");
|
|
|
|
var collected_packet = new CollectedPacketInfo(packetUid, totalPacketCount, packetIdx, datas);
|
|
//var user_guid = player.getUserGuid();
|
|
|
|
var result = addCollectedPacket(ssesion, collected_packet);
|
|
return result;
|
|
}
|
|
|
|
|
|
private Result addCollectedPacket(IEntityWithSession ssesion, CollectedPacketInfo packet)
|
|
{
|
|
using (_lock.Lock())
|
|
{
|
|
if (false == m_large_packets.TryGetValue(ssesion, out var collected_packets))
|
|
{
|
|
collected_packets = new SortedSet<CollectedPacketInfo>();
|
|
collected_packets.Add(packet);
|
|
m_large_packets.TryAdd(ssesion, collected_packets);
|
|
}
|
|
else
|
|
{
|
|
collected_packets.Add(packet);
|
|
}
|
|
|
|
}
|
|
Log.getLogger().debug($"addCollectedPacket done");
|
|
return new Result();
|
|
}
|
|
|
|
private Result removeCollectedPacket(List<IEntityWithSession> sessionIds)
|
|
{
|
|
|
|
if (sessionIds.Count == 0) return new();
|
|
|
|
var result = new Result();
|
|
using (_lock.Lock())
|
|
{
|
|
foreach (var session_id in sessionIds)
|
|
{
|
|
m_large_packets.TryRemove(session_id, out var _);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public Task<Result> checkLargePacket()
|
|
{
|
|
var result = new Result();
|
|
List<IEntityWithSession> delete_users = new();
|
|
foreach (var packets in m_large_packets)
|
|
{
|
|
var session = packets.Key;
|
|
var packet_set = packets.Value;
|
|
|
|
var isRecvResult = validCheck(session, packet_set);
|
|
if (isRecvResult.isSuccess())
|
|
{
|
|
if (false == processPacket(session, packet_set))
|
|
{
|
|
Log.getLogger().error("processPacket error!!");
|
|
delete_users.Add(session);
|
|
break;
|
|
}
|
|
|
|
delete_users.Add(session);
|
|
continue;
|
|
}
|
|
|
|
if (isRecvResult.getErrorCode() == ServerErrorCode.LargePacketNotAllReceived) continue;
|
|
if (isRecvResult.getErrorCode() != ServerErrorCode.LargePacketRecvTimeOver)
|
|
{
|
|
send_GS2C_NTF_LARGE_PACKET_TIMEOUT(session, isRecvResult, packet_set);
|
|
delete_users.Add(session);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (delete_users.Count > 0)
|
|
{
|
|
removeCollectedPacket(delete_users);
|
|
}
|
|
|
|
return Task.FromResult(result);
|
|
}
|
|
|
|
private void send_GS2C_NTF_LARGE_PACKET_TIMEOUT(IEntityWithSession session, Result result, SortedSet<CollectedPacketInfo> packetSet)
|
|
{
|
|
var last_recv_time = packetSet.OrderByDescending(p => p.m_last_recv_time).FirstOrDefault();
|
|
NullReferenceCheckHelper.throwIfNull(last_recv_time, () => $"Last Receive time is null !! - player:{session.toBasicString()}");
|
|
|
|
// var uid = packetSet.Select(p => p.m_packet_uid).FirstOrDefault() ?? string.Empty;
|
|
|
|
ClientToGame msg = new();
|
|
msg.Message = new();
|
|
msg.Message.NtfLargePacketTimeout = new();
|
|
msg.Message.NtfLargePacketTimeout.Uid = last_recv_time.m_packet_uid;
|
|
msg.Message.NtfLargePacketTimeout.LastCheckTime = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(last_recv_time.m_last_recv_time);
|
|
msg.Message.NtfLargePacketTimeout.LastCheckTime = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.UtcNow);
|
|
}
|
|
|
|
private bool processPacket(IEntityWithSession session, SortedSet<CollectedPacketInfo> packets)
|
|
{
|
|
var network_session = getNetworkSession();
|
|
|
|
using (var stream = new MemoryStream())
|
|
{
|
|
foreach (var packet in packets)
|
|
{
|
|
if (packet.m_datas == null)
|
|
{
|
|
Log.getLogger().warn("Warning: packet.m_datas is null");
|
|
continue;
|
|
}
|
|
packet.m_datas.WriteTo(stream);
|
|
}
|
|
|
|
if (stream.Length == 0)
|
|
{
|
|
Log.getLogger().warn("Warning: stream is empty after writing packets.");
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
stream.Position = 0;
|
|
var req = ClientToGame.Parser.ParseFrom(stream);
|
|
|
|
var func = network_session.onCallProtocolHandler(session, req);
|
|
return true;
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.getLogger().error($"Exception !!!, Failed to perform !!!, in LargePacketHandler.processPacket() : exception:{e} - {session.toBasicString()}");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private Result validCheck(IEntityWithSession session, SortedSet<CollectedPacketInfo> packets)
|
|
{
|
|
var err_msg = string.Empty;
|
|
var result = new Result();
|
|
|
|
var sorted_packet_idxs = packets.OrderBy(p => p.m_packet_idx).ToList();
|
|
var total_packet_count = packets.Select(p => p.m_total_packet_count).FirstOrDefault();
|
|
|
|
//아직 패킷이 다 안들어온거다.
|
|
if (sorted_packet_idxs.Count < total_packet_count)
|
|
{
|
|
err_msg = $"Not all packets were received !!! : recvPacketCount:{sorted_packet_idxs.Count} < totalPacketCount:{total_packet_count} - {session.toBasicString()}";
|
|
result.setFail(ServerErrorCode.LargePacketNotAllReceived, err_msg);
|
|
return result;
|
|
}
|
|
|
|
var last_recv_time = packets.OrderByDescending(p => p.m_last_recv_time).FirstOrDefault();
|
|
NullReferenceCheckHelper.throwIfNull(last_recv_time, () => $"last receive time is null !!! - {session.toBasicString()}");
|
|
|
|
var diff = DateTimeHelper.Current - last_recv_time.m_last_recv_time;
|
|
if (diff.TotalSeconds > Constant.LARGE_PACKET_CHECK_WAIT_SEC)
|
|
{
|
|
err_msg = $"Packet receive timeout exceeded !!! : waitingSec:{diff.TotalSeconds} > WaitMaxSec:{Constant.LARGE_PACKET_CHECK_WAIT_SEC}, lastRecvTime:{last_recv_time} - {session.toBasicString()}";
|
|
result.setFail(ServerErrorCode.LargePacketRecvTimeOver, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
return result;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public SessionBase getNetworkSession()
|
|
{
|
|
NullReferenceCheckHelper.throwIfNull(m_network_session, () => $"m_network_session is null !!!");
|
|
return m_network_session;
|
|
}
|
|
}
|
|
|
|
|
|
public class CollectedPacketInfo : IComparable<CollectedPacketInfo>
|
|
{
|
|
public string m_packet_uid { get; } = string.Empty;
|
|
public Int32 m_total_packet_count { get; } = 0;
|
|
public Int32 m_packet_idx { get; } = 0;
|
|
public ByteString? m_datas { get; } = null;
|
|
public DateTime m_last_recv_time { get; } = DateTime.Now;
|
|
public CollectedPacketInfo(string packetUid, Int32 totalPacketCount, Int32 packetIdx, ByteString datas)
|
|
{
|
|
m_packet_uid = packetUid;
|
|
m_total_packet_count = totalPacketCount;
|
|
m_packet_idx = packetIdx;
|
|
m_datas = datas;
|
|
}
|
|
|
|
public Int32 CompareTo(CollectedPacketInfo? other)
|
|
{
|
|
if (other == null) return 1;
|
|
return this.m_packet_idx.CompareTo(other.m_packet_idx);
|
|
}
|
|
|
|
public override bool Equals(object? obj)
|
|
{
|
|
if (obj == null || GetType() != obj.GetType())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CollectedPacketInfo other = (CollectedPacketInfo)obj;
|
|
//return m_packet_uid == other.m_packet_uid &&
|
|
// m_total_packet_count == other.m_total_packet_count &&
|
|
// m_packet_idx == other.m_packet_idx &&
|
|
// m_last_recv_time == other.m_last_recv_time;
|
|
return m_packet_idx == other.m_packet_idx;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return HashCode.Combine(m_packet_uid, m_total_packet_count, m_packet_idx, m_last_recv_time);
|
|
}
|
|
}
|
|
|