/// <summary>
/// 모든 클라한테 전송
/// </summary>
public void Broadcast(INetworkPacket packet)
{
foreach (NetworkClient client in ConnectedClients.Values)
{
SendTo(client, packet);
}
}
/// <summary>
/// 모든 클라한테 전송
/// </summary>
/// <param name="packet">전송하는 패킷</param>
/// <param name="except">제외할 클라들</param>
public void BroadcastExcept(INetworkPacket packet, NetworkClient[] except)
{
foreach (NetworkClient client in ConnectedClients.Values.Except(except))
{
SendTo(client, packet);
}
}
public Task SendAsync(INetworkPacket package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (_serializer == null)
{
throw new NullReferenceException(nameof(_serializer));
}
if (_serialPort == null)
{
throw new NullReferenceException(nameof(_serialPort));
}
if (!_serialPort.IsOpen)
{
throw new Exception("Serial port is not open.");
}
using (var stream = new MemoryStream())
{
var length = _serializer.Serialize(package, stream);
_serialPort.Write(stream.ToArray(), 0, length);
return(Task.CompletedTask);
}
}
public void OnReceivePacket(NetworkClient client, INetworkPacket packet)
{
if (packet.GetType() == typeof(PtkClientConnect))
{
lock (_ConnectWaitingClientLocker)
{
if (_ConnectWaitingClient.Contains(client))
{
_ConnectWaitingClient.Remove(client);
}
}
lock (ConnectedClientsLocker)
{
if (ConnectedClients.ContainsKey(packet.ID))
{
ConnectedClients[packet.ID] = client;
}
else
{
ConnectedClients.Add(packet.ID, client);
}
}
}
_TcpReceivePacketStreamer.RegisterPacket(packet.ID, packet);
}
public int Serialize(INetworkPacket packet, BinaryWriter writer)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
switch (packet)
{
case AckFrame ackFrame: return(Serialize(ackFrame, writer));
case ShortFrame shortFrame: return(Serialize(shortFrame, writer));
case LongFrame longFrame: return(Serialize(longFrame, writer));
case ControlFrame controlFrame: return(Serialize(controlFrame, writer));
default: throw new NotImplementedException();
}
}
private void OnReceivePacket()
{
while (Connected)
{
int readBytesCount = 0;
try
{
readBytesCount = _Stream.Read(_ReciveBytes, 0, _ReciveBytes.Length);
}
catch
{
NetworkServer.Get().Disconnect(this);
}
if (readBytesCount > 0)
{
INetworkPacket networkPacket = _ReciveBytes.ToNetworkPacket();
NetworkServer.Get().OnReceivePacket(this, networkPacket);
}
else
{
break;
}
}
NetworkServer.Get().Disconnect(this);
}
public void RegisterPacket(long id, INetworkPacket packet)
{
_PackerProcesser.Enqueue(new NetworkPacketPair()
{
ID = id, Packet = packet
});
}
public void BroadcastExcept(INetworkPacket packet, long[] except)
{
foreach (NetworkClient client in ConnectedClients.Values.Where(x => !except.Contains(x.ID)))
{
SendTo(client, packet);
}
}
public void Proccess(NetworkClient client, INetworkPacket packet)
{
if (_PacketMap.TryGetValue(packet.GetType(), out Action <NetworkClient, INetworkPacket> func))
{
func(client, packet);
}
}
private static ArchitectureAttribute GetArchitectureFromPacket(INetworkPacket packet)
{
return(packet
.GetType()
.GetCustomAttributes(typeof(ArchitectureAttribute), false)
.OfType <ArchitectureAttribute>()
.FirstOrDefault());
}
public int Serialize(INetworkPacket packet, BinaryWriter writer)
{
var queryPackage = packet as QueryPacket;
writer.Write(queryPackage.Data);
return(queryPackage.Data.Length);
}
public static byte[] ToByteArray(this INetworkPacket packet)
{
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream Stream = new MemoryStream();
formatter.Serialize(Stream, packet);
return(Stream.ToArray());
}
public void OnInitialDataReceived(Player player, INetworkPacket data)
{
var credentials = (LoginCredentials)data;
Debug.Log(credentials.Username + " has connected!");
CreatePlayer(player, credentials);
}
protected WebModel.INetworkPacket CreateNetworkPacket(WebModel.IEntity entity, Uri uri)
{
INetworkPacket packet = NetworkModel.Factory.CreateObject <INetworkPacket>();
packet.Source = uri;
packet.TypeIdentifier = entity.GetType().GUID;
packet.Entity = Mapper.MapWebModelToDataModelEntities(entity);
return(new NetworkPacket(packet, Serializer));
}
public static bool CanServerReceive(this INetworkPacket packet)
{
ArchitectureAttribute attrib = GetArchitectureFromPacket(packet);
if (attrib == null)
{
throw new Exception($"NetworkPacket[ID:{packet.GetPacketNumber()}] doesn't specify a packet architecture.");
}
return(attrib.Architecture.HasFlag(PacketArchitecture.ClientToServer));
}
private async Task ReceiveWorker(CancellationToken cancellationToken)
{
Microsoft.Azure.Devices.Client.Message message = null;
INetworkPacket packet = null;
while (!cancellationToken.IsCancellationRequested)
{
try
{
message = await _device.Receive();
if (message == null)
{
continue;
}
var messageType = MessageType.PULL_RESP;// Enum.Parse(typeof(MessageType), message.Properties["MessageType"]);
var data = message.GetBytes();
_logger.Info($"Receiving '{messageType}' packet from IoT Hub by deviceid '{_deviceId}'", GetType().Name);
switch (messageType)
{
case MessageType.PULL_RESP:
{
packet = new PullRespPacket
{
ProtocolVersion = int.Parse(message.Properties["ProtocolVersion"]),
//Token = message.Properties["Token"],
Payload = _payloadSerializer.Deserialize <PullRespPacketPayload>(data),
};
}
break;
default:
{
continue;
}
}
PacketReceived(this, new PacketEventArgs(packet, this));
}
catch (BrokenCircuitException ex)
{
_logger.Error($"Circuit breaker open -> An error occured while receiving a message from IoT Hub by deviceid '{_deviceId}'", GetType().Name, ex);
await Task.Delay(TimeSpan.FromSeconds(30));
}
catch (Exception ex)
{
_logger.Error($"An error occured while receiving a message from IoT Hub by deviceid '{_deviceId}'", GetType().Name, ex);
}
}
}
public void Proccess(INetworkPacket packet)
{
if (_PacketMap.TryGetValue(packet.GetType(), out Action <INetworkPacket> func))
{
func(packet);
}
else
{
Debug.LogError(packet.GetType() + " 메시지가 도착함 해당 패킷에 대한 기능이 패킷 맵에 등록되어 있지 않아요!");
}
}
public bool CanPlayerAuth(INetworkPacket data)
{
var credentials = (LoginCredentials)data;
if (credentials.ServerVersion < _serverVersion)
{
return(false);
}
return(true);
}
public static INetworkPacket ToNetworkPacket(this byte[] bytes)
{
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream Stream = new MemoryStream();
Stream.Write(bytes, 0, bytes.Length);
Stream.Seek(0, SeekOrigin.Begin);
INetworkPacket clientInfo = (INetworkPacket)formatter.Deserialize(Stream);
return(clientInfo);
}
// ========================================================================== //
#region Private
private void SendPacket(Class_SessionDerived pSessionRecv, byte[] arrByte, INetworkPacket pPacket, int iPort, bool bIsReliableResend = false)
{
IPEndPoint pSendIP = new IPEndPoint(IPAddress.Parse(pSessionRecv.p_strIP), iPort);
_pClientUDP_Send.Send(arrByte, arrByte.Length, pSendIP);
INetworkPacket_Reliable pPacketIsReliable = pPacket as INetworkPacket_Reliable;
if (bIsReliableResend == false && pPacketIsReliable != null)
{
pSessionRecv.DoAddReliablePacket(pPacketIsReliable, arrByte, iPort);
}
}
public int Serialize(INetworkPacket packet, Stream stream)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
return(Serialize(packet, new BinaryWriter(stream)));
}
private async Task SendWorker(CancellationToken cancellationToken)
{
INetworkPacket networkPacket = null;
while (!cancellationToken.IsCancellationRequested)
{
try
{
if (!_queue.TryDequeue(out networkPacket))
{
//await Task.Delay(100);
continue;
}
var correlationId = Guid.NewGuid();
switch (networkPacket)
{
case PushDataPacket pushDataPacket:
{
var data = _payloadSerializer.Serialize(pushDataPacket.Payload);
var message = new Microsoft.Azure.Devices.Client.Message(data);
message.CorrelationId = correlationId.ToString();
message.Properties["EventId"] = correlationId.ToString();
message.Properties["CorrelationId"] = correlationId.ToString();
message.Properties["DeviceId"] = pushDataPacket.Eui;
message.Properties["ProtocolName"] = "Lora Packet Forwarder";
message.Properties["ProtocolVersion"] = pushDataPacket.ProtocolVersion.ToString();
message.Properties["MessageType"] = pushDataPacket.MessageType.ToString();
message.CreationTimeUtc = DateTime.UtcNow;
_logger.Info($"Sending PushDataPacket to IoT Hub by deviceid '{_deviceId}'", GetType().Name);
await _device.Send(message);
}
break;
}
}
catch (BrokenCircuitException ex)
{
_logger.Error($"Circuit breaker open -> An error occured while sending a message to IoT Hub by deviceid '{_deviceId}'. Discarding message", GetType().Name, ex);
}
catch (Exception ex)
{
_logger.Error($"An error occured while sending a message to IoT Hub by deviceid '{_deviceId}'", GetType().Name, ex);
}
}
}
public static INetworkPacket Deserialize(byte[] source, ISerializer <INetworkPacket> serializer)
{
ISerializer <Entity> entitySerializer = new Serializer <Entity>(serializer.Encoding, serializer.Formatter.Format);
(int separatorStartIndex, int separatorEndIndex) = GetEntitySeparatorRange(source, serializer);
Span <byte> entityBytes = source.AsSpan(separatorEndIndex, source.Length - separatorEndIndex);
Span <byte> networkEntityBytes = source.AsSpan(0, separatorStartIndex == -1 ? source.Length : separatorStartIndex);
INetworkPacket entity = serializer.Deserialize(networkEntityBytes.ToArray());
if (separatorStartIndex != -1)
{
entity.Entity = entitySerializer.Deserialize(entityBytes.ToArray());
}
return(entity);
}
private byte[] CombineBuffer_Header_And_Packet(INetworkPacket pPacket, byte[] arrByte)
{
bool bIsGenerate;
Packet_Header pPacketHeader;
OnGeneratePacketHeader(pPacket, out bIsGenerate, out pPacketHeader);
_pBufferSend.Clear();
if (bIsGenerate)
{
pPacketHeader.INetworkPacketHeader_Set_Header(arrByte.Length, pPacket.INetworkPacket_Get_PacketID());
_pBufferSend.Enqueue(ByteExtension.ConvertByteArray(pPacketHeader));
}
_pBufferSend.Enqueue(ByteExtension.ConvertByteArray(pPacket));
return(_pBufferSend.Dequeue_OrNull(_pBufferSend.Count));
}
public bool SendEntity(INetworkPacket packet, Func <INetworkPacket, byte[]> serializer)
{
foreach ((Memory <byte> chunk, bool last) in SplitObjectIntoBufferSizedChunks(packet, serializer))
{
chunk.CopyTo(_buffer.Array.AsMemory());
try
{
_wsContext.WebSocket?.SendAsync(_buffer, WebSocketMessageType.Binary, last, _token);
}
catch (WebSocketException ex)
{
_wsContext.WebSocket?.CloseAsync(WebSocketCloseStatus.InternalServerError, ex.Message, _token);
return(false);
}
}
return(true);
}
public Task SendAsync(INetworkPacket package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (_socket == null)
{
throw new NullReferenceException(nameof(_socket));
}
if (_serializer == null)
{
throw new NullReferenceException(nameof(_serializer));
}
if (_endpoint == null)
{
throw new NullReferenceException(nameof(_endpoint));
}
using (var stream = new MemoryStream())
{
var length = _serializer.Serialize(package, stream);
var state = new OrderedAsyncState();
state.Client = _socket;
state.ReadEventArgs.RemoteEndPoint = _endpoint;
state.ReadEventArgs.SetBuffer(stream.ToArray(), 0, length);
state.ReadEventArgs.AcceptSocket = _socket;
state.ReadEventArgs.UserToken = state;
state.ReadEventArgs.Completed += OnCompleted;
state.ReceiveAsync = e =>
{
var receiveBuffer = new byte[MAX_BUFFER_SIZE];
e.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
return(e.AcceptSocket.ReceiveAsync(e));
};
var result = _socket.SendToAsync(state.ReadEventArgs);
return(Task.CompletedTask);
}
}
public void SendMessage(PacketDeliveryMethod method, INetworkPacket packet, string accountName)
{
if (!_usernameToConnection.ContainsKey(accountName))
{
return;
}
NetConnection recipient = _usernameToConnection[accountName];
NetOutgoingMessage message = _server.CreateMessage();
MemoryStream stream = new MemoryStream();
Serializer.Serialize(stream, packet);
message.Write(stream.ToArray());
// This may seem redundant but I am protecting against the possibility that
// Lidgren is vaporware. Should we need to swap out the network code in the future,
// only this class will need to be touched.
NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unreliable;
switch (method)
{
case PacketDeliveryMethod.Unreliable:
deliveryMethod = NetDeliveryMethod.Unreliable;
break;
case PacketDeliveryMethod.UnreliableSequenced:
deliveryMethod = NetDeliveryMethod.UnreliableSequenced;
break;
case PacketDeliveryMethod.ReliableUnordered:
deliveryMethod = NetDeliveryMethod.ReliableUnordered;
break;
case PacketDeliveryMethod.ReliableSequenced:
deliveryMethod = NetDeliveryMethod.ReliableSequenced;
break;
case PacketDeliveryMethod.ReliableOrdered:
deliveryMethod = NetDeliveryMethod.ReliableOrdered;
break;
}
_server.SendMessage(message, recipient, deliveryMethod);
}
public void SendMessage(PacketDeliveryMethod method, INetworkPacket packet)
{
if (_serverConnection == null ||
_serverConnection.Status != NetConnectionStatus.Connected)
{
throw new Exception("Client is not currently connected to a server.");
}
NetOutgoingMessage message = _client.CreateMessage();
MemoryStream stream = new MemoryStream();
Serializer.Serialize(stream, packet);
message.Write(stream.ToArray());
// This may seem redundant but I am protecting against the possibility that
// Lidgren is vaporware. Should we need to swap out the network code in the future,
// only this class will need to be touched.
NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unreliable;
switch (method)
{
case PacketDeliveryMethod.Unreliable:
deliveryMethod = NetDeliveryMethod.Unreliable;
break;
case PacketDeliveryMethod.UnreliableSequenced:
deliveryMethod = NetDeliveryMethod.UnreliableSequenced;
break;
case PacketDeliveryMethod.ReliableUnordered:
deliveryMethod = NetDeliveryMethod.ReliableUnordered;
break;
case PacketDeliveryMethod.ReliableSequenced:
deliveryMethod = NetDeliveryMethod.ReliableSequenced;
break;
case PacketDeliveryMethod.ReliableOrdered:
deliveryMethod = NetDeliveryMethod.ReliableOrdered;
break;
}
_client.SendMessage(message, deliveryMethod);
}
private async Task ReadEntity(ArraySegment <byte> buffer, CancellationToken token)
{
List <byte> receivedBytes = new List <byte>(BUFFER_SIZE);
WebSocketReceiveResult response;
do
{
response = await _webSocket?.ReceiveAsync(buffer, token);
receivedBytes.AddRange(buffer);
}while (!response.EndOfMessage);
int endIndex = receivedBytes.LastIndexOf(0x03);
if (endIndex > 0)
{
receivedBytes.RemoveRange(endIndex, receivedBytes.Count - endIndex);
}
INetworkPacket networkEntity = AbstractNetworkPacket.Deserialize(receivedBytes.ToArray(), Serializer);
InvokeEntityChanged(networkEntity.Entity as IEntity);
}
private static IEnumerable <(Memory <byte> chunk, bool last)> SplitObjectIntoBufferSizedChunks(
INetworkPacket entity,
Func <INetworkPacket, byte[]> serializer)
{
byte[] fullArray = serializer.Invoke(entity);
int chunksCount = (int)Math.Ceiling((decimal)fullArray.Length / BUFFER_SIZE);
byte[] appendedArray = new byte[chunksCount * BUFFER_SIZE];
Memory <byte> memory = appendedArray.AsMemory();
fullArray.CopyTo(memory);
if (fullArray.Length != memory.Length)
{
appendedArray[fullArray.Length] = 0x03;
}
for (int i = 0; i < chunksCount; ++i)
{
bool lastChunk = i == chunksCount - 1;
yield return(memory.Slice(i * BUFFER_SIZE, BUFFER_SIZE), lastChunk);
}
}
