public Server(ILogger logger, IDatabase database)
{
_logger = logger;
_database = database;
foreach (var method in GetType().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
var attribute = method.GetCustomAttribute <PacketAttribute>();
if (attribute != null)
{
if (_packetMethods.ContainsKey(attribute.Header))
{
throw new InvalidProgramException($"Duplicate headers of packet method '{method.Name}'. Overloading is not supported.");
}
var packetMethod = new PacketMethod(this, attribute.Header, method);
var parameters = method.GetParameters();
foreach (var parameter in parameters)
{
if (string.Compare(parameter.Name, "client", true) == 0)
{
if (parameter.ParameterType != typeof(ServerClient))
{
throw new InvalidProgramException($"Invalid dependency injection parameter type for method: {method.Name}");
}
packetMethod.AddParameter(PacketMethodParameter.Client);
}
else if (string.Compare(parameter.Name, "requestId", true) == 0)
{
if (parameter.ParameterType != typeof(int))
{
throw new InvalidProgramException($"Invalid dependency injection parameter type for method: {method.Name}");
}
packetMethod.AddParameter(PacketMethodParameter.RequestId);
}
else if (string.Compare(parameter.Name, "buffer", true) == 0)
{
if (parameter.ParameterType != typeof(DataBuffer))
{
throw new InvalidProgramException($"Invalid dependency injection parameter type for method: {method.Name}");
}
packetMethod.AddParameter(PacketMethodParameter.Buffer);
}
else
{
throw new InvalidProgramException($"Invalid dependency parameter for method '{method.Name}': ({parameter.ParameterType.FullName}) {parameter.Name}");
}
}
packetMethod.UpdateParameters();
_packetMethods.Add(attribute.Header, packetMethod);
}
}
}
public static bool AddPacketHandler(PacketType packetType, PacketMethod handler)
{
bool result = false;
lock (PacketHandlers) {
if (!PacketHandlers.ContainsKey(packetType))
{
PacketHandlers.Add(packetType, handler);
result = true;
}
}
return(result);
}
public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool runasync)
{
bool result = false;
lock (m_packetHandlers) {
if (!m_packetHandlers.ContainsKey(packetType))
{
m_packetHandlers.Add(packetType, new PacketProcessor {
method = handler, Async = runasync
});
result = true;
}
}
return(result);
}
/// <summary>
/// Try to process a packet using registered packet handlers
/// </summary>
/// <param name="packet"></param>
/// <returns>True if a handler was found which successfully processed the packet.</returns>
bool ProcessPacketMethod(Packet packet)
{
bool result = false;
PacketProcessor pprocessor;
bool localHandler;
lock (m_packetHandlers) {
localHandler = m_packetHandlers.TryGetValue(packet.Type, out pprocessor);
}
if (localHandler)
{
//there is a local handler for this packet type
if (pprocessor.Async)
{
object obj = new AsyncPacketProcess(this, pprocessor.method, packet);
m_udpServer.FireAndForget(ProcessSpecificPacketAsync, obj);
result = true;
}
else
{
result = pprocessor.method(this, packet);
}
return(result);
}
//there is not a local handler so see if there is a Global handler
PacketMethod method = null;
bool found;
lock (PacketHandlers) {
found = PacketHandlers.TryGetValue(packet.Type, out method);
}
if (found)
{
result = method(this, packet);
}
return(result);
}
public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)
{
bool result = false;
lock (m_packetHandlers)
{
if (!m_packetHandlers.ContainsKey(packetType))
{
m_packetHandlers.Add(packetType, handler);
result = true;
}
}
return result;
}
public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)
{
return(AddLocalPacketHandler(packetType, handler, true));
}
public AsyncPacketProcess(LLClientView pClientview, PacketMethod pMethod, Packet pPack)
{
ClientView = pClientview;
Method = pMethod;
Pack = pPack;
}
