public ClientPacketProcessor(ClientBuilderOptions options,
IPacketSerialiser packetSerialiser,
ILogger logger,
IPacketHandlers packetHandlers)
{
this.options = options;
this.packetSerialiser = packetSerialiser;
this.logger = logger;
this.packetHandlers = packetHandlers;
this.tcpSenderObjectPool = new ObjectPool <ISender>(options.ObjectPoolSize);
for (var i = 0; i < this.tcpSenderObjectPool.Capacity; i++)
{
this.tcpSenderObjectPool.Push(new TcpSender(packetSerialiser));
}
this.udpSenderObjectPool = new ObjectPool <ISender>(options.ObjectPoolSize);
for (var i = 0; i < this.udpSenderObjectPool.Capacity; i++)
{
this.udpSenderObjectPool.Push(new UdpSender(packetSerialiser));
}
this.bytePool = new ObjectPool <byte[]>(options.ObjectPoolSize);
for (int i = 0; i < this.bytePool.Capacity; i++)
{
this.bytePool.Push(new byte[options.PacketSizeBuffer]);
}
}
public ServerPacketProcessor(ServerBuilderOptions options,
ILogger <ServerPacketProcessor> logger,
IPacketHandlers packetHandlers,
IServerInformation serverInformation,
IPacketSerialiser packetSerialiser)
{
this.logger = logger;
this.packetHandlers = packetHandlers;
this.serverInformation = serverInformation;
this.packetSerialiser = packetSerialiser;
tcpSenderObjectPool = new ObjectPool <ISender>(options.TcpMaxConnections);
for (var i = 0; i < tcpSenderObjectPool.Capacity; i++)
{
tcpSenderObjectPool.Push(new TcpSender(packetSerialiser));
}
udpSenderObjectPool = new ObjectPool <ISender>(options.TcpMaxConnections * 2);
for (var i = 0; i < udpSenderObjectPool.Capacity; i++)
{
udpSenderObjectPool.Push(new UdpSender(packetSerialiser));
}
}
public ServerPacketProcessor(ServerBuilderOptions options,
ILogger <ServerPacketProcessor> logger,
IPacketHandlers packetHandlers,
IServerInformation serverInformation,
IPacketSerialiser packetSerialiser,
IEnumerable <IMiddlewareHandler> middlewares)
{
this.logger = logger;
this.packetHandlers = packetHandlers;
this.serverInformation = serverInformation;
this.packetSerialiser = packetSerialiser;
this.middlewares = middlewares.ToList();
tcpSenderObjectPool = new ObjectPool <ISender>(options.TcpMaxConnections);
for (var i = 0; i < tcpSenderObjectPool.Capacity; i++)
{
tcpSenderObjectPool.Push(new TcpSender(packetSerialiser));
}
udpSenderObjectPool = new ObjectPool <ISender>(options.TcpMaxConnections * 2);
for (var i = 0; i < udpSenderObjectPool.Capacity; i++)
{
udpSenderObjectPool.Push(new UdpSender(_socketSender));
}
packetContextObjectPool = new ObjectPool <IPacketContext>(options.TcpMaxConnections * 2);
for (var i = 0; i < packetContextObjectPool.Capacity; i++)
{
packetContextObjectPool.Push(new PacketContext());
}
}
public override IServiceProvider GetServiceProvider(IServiceProvider serviceProvider = null)
{
try
{
if (serviceProvider == null)
{
serviceProvider = this.serviceProviderFactory != null?this.serviceProviderFactory.Invoke() : serviceCollection.BuildServiceProvider();
}
PacketSerialiserProvider.PacketSerialiser = serviceProvider.GetService <IPacketSerialiser>();
IPacketHandlers packetHandlers = serviceProvider.GetService <IPacketHandlers>();
foreach (var packetHandlerModule in this.modules)
{
foreach (var packetHandler in packetHandlerModule.GetPacketHandlers())
{
packetHandlers.Add(PacketSerialiserProvider.PacketSerialiser.CanReadName ? packetHandler.Key.Name : "Default",
(IPacketHandler)serviceProvider.GetService(packetHandler.Value));
}
}
if (!PacketSerialiserProvider.PacketSerialiser.CanReadName && packetHandlers.GetPacketHandlers().Count > 1)
{
throw new Exception("A PacketSerialiser which cannot identify a packet can only support up to one packet type");
}
}
catch (Exception ex)
{
}
return(serviceProvider);
}
protected IServiceProvider GetServiceProvider()
{
var serviceProvider = this.serviceProviderFactory != null?serviceProviderFactory.Invoke() : this.serviceCollection.BuildServiceProvider();
PacketSerialiserProvider.PacketSerialiser = serviceProvider.GetService <IPacketSerialiser>();
serviceProvider.GetService <ILogLevelProvider>().SetLogLevel(this.options.LogLevel);
IPacketHandlers packetHandlers = serviceProvider.GetService <IPacketHandlers>();
foreach (var packetHandlerModule in this.modules)
{
foreach (var packetHandler in packetHandlerModule.GetPacketHandlers())
{
packetHandlers.Add(PacketSerialiserProvider.PacketSerialiser.CanReadName ? packetHandler.Key.Name : "Default",
(IPacketHandler)serviceProvider.GetService(packetHandler.Value));
}
}
if (!PacketSerialiserProvider.PacketSerialiser.CanReadName && packetHandlers.GetPacketHandlers().Count > 1)
{
throw new Exception("A PacketSerialiser which cannot identify a packet can only support up to one packet type");
}
return(serviceProvider);
}
public Server(ServerBuilderOptions options,
ILogger logger,
IServiceProvider serviceProvider,
IPacketHandlers packetHandlers,
ITcpConnections tcpConnections,
IServerPacketProcessor serverPacketProcessor,
ITcpSocketListenerFactory tcpSocketListenerFactory,
IUdpSocketListenerFactory udpSocketListenerFactory,
IBufferManager bufferManager,
IServerInformation serverInformation,
IPacketSerialiser packetSerialiser)
{
this.tcpConnections = tcpConnections;
this.serverInformation = serverInformation;
this.packetSerialiser = packetSerialiser;
bufferManager.InitBuffer();
if (options.TcpPort > 0)
{
this.TcpListener = tcpSocketListenerFactory.Create();
}
if (options.UdpPort > 0)
{
this.UdpListener = udpSocketListenerFactory.Create();
}
Task.Factory.StartNew(() =>
{
while (this.serverInformation.IsRunning)
{
if (this.eventArgs == null)
{
this.eventArgs = new ServerInformationEventArgs();
}
this.eventArgs.ProcessedTcpPackets =
serverInformation.ProcessedTcpPackets;
this.eventArgs.InvalidTcpPackets =
serverInformation.InvalidTcpPackets;
this.eventArgs.ProcessedUdpPackets =
serverInformation.ProcessedUdpPackets;
this.eventArgs.InvalidUdpPackets =
serverInformation.InvalidUdpPackets;
this.eventArgs.TcpConnections = tcpConnections.GetConnections()
.Count;
this.ServerInformationUpdated?.Invoke(this, this.eventArgs);
this.serverInformation.ProcessedTcpPackets = 0;
this.serverInformation.InvalidTcpPackets = 0;
this.serverInformation.ProcessedUdpPackets = 0;
this.serverInformation.InvalidUdpPackets = 0;
Thread.Sleep(10000);
}
});
}
public ClientPacketProcessor(ClientBuilderOptions options,
IPacketSerialiser packetSerialiser,
ILogger <ClientPacketProcessor> logger,
IPacketHandlers packetHandlers)
{
this.options = options;
this.packetSerialiser = packetSerialiser;
this.logger = logger;
this.packetHandlers = packetHandlers;
tcpSenderObjectPool = new ObjectPool <ISender>(options.ObjectPoolSize);
for (var i = 0; i < tcpSenderObjectPool.Capacity; i++)
{
tcpSenderObjectPool.Push(new TcpSender(packetSerialiser));
}
udpSenderObjectPool = new ObjectPool <ISender>(options.ObjectPoolSize);
for (var i = 0; i < udpSenderObjectPool.Capacity; i++)
{
udpSenderObjectPool.Push(new UdpSender(_udpSocketSender));
}
_packetContextObjectPool = new ObjectPool <IPacketContext>(options.ObjectPoolSize * 2);
for (var i = 0; i < _packetContextObjectPool.Capacity; i++)
{
_packetContextObjectPool.Push(new PacketContext()
{
Serialiser = this.packetSerialiser
});
}
bytePool = new ObjectPool <byte[]>(options.ObjectPoolSize);
for (var i = 0; i < bytePool.Capacity; i++)
{
bytePool.Push(new byte[options.PacketSizeBuffer]);
}
}
