public Task StartAsync(CancellationToken cancellationToken)
{
Logger.LogInformation($"JT808 Udp Server start at {IPAddress.Any}:{ConfigurationMonitor.CurrentValue.UdpPort}.");
Task.Factory.StartNew(async() => {
while (!cancellationToken.IsCancellationRequested)
{
var buffer = ArrayPool <byte> .Shared.Rent(ConfigurationMonitor.CurrentValue.MiniNumBufferSize);
try
{
var segment = new ArraySegment <byte>(buffer);
SocketReceiveMessageFromResult result = await server.ReceiveMessageFromAsync(segment, SocketFlags.None, LocalIPEndPoint);
ReaderBuffer(buffer.AsSpan(0, result.ReceivedBytes), server, result);
}
catch (System.ObjectDisposedException ex)
{
//Logger.LogInformation("Socket Received Bytes Close");
}
catch (AggregateException ex)
{
Logger.LogError(ex, "Receive MessageFrom Async");
}
catch (Exception ex)
{
Logger.LogError(ex, $"Received Bytes");
}
finally
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
}, cancellationToken);
return(Task.CompletedTask);
}
public Task StartAsync(CancellationToken cancellationToken)
{
Logger.LogInformation($"JT808 Udp Server start at {IPAddress.Any}:{Configuration.UdpPort}.");
Task.Run(async() => {
while (!cancellationToken.IsCancellationRequested)
{
var buffer = ArrayPool <byte> .Shared.Rent(Configuration.MiniNumBufferSize);
try
{
var segment = new ArraySegment <byte>(buffer);
SocketReceiveMessageFromResult result = await server.ReceiveMessageFromAsync(segment, SocketFlags.None, LocalIPEndPoint);
ReaderBuffer(buffer.AsSpan(0, result.ReceivedBytes), server, result);
}
catch (AggregateException ex)
{
Logger.LogError(ex, "Receive MessageFrom Async");
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
{
Logger.LogError(ex, $"Received Bytes");
}
#pragma warning restore CA1031 // Do not catch general exception types
finally
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
}, cancellationToken);
return(Task.CompletedTask);
}
private void ReaderBuffer(ReadOnlySpan <byte> buffer, Socket socket, SocketReceiveMessageFromResult receiveMessageFromResult)
{
try
{
var package = Serializer.HeaderDeserialize(buffer, minBufferSize: 10240);
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace($"[Accept Hex {receiveMessageFromResult.RemoteEndPoint}]:{package.OriginalData.ToHexString()}");
}
var session = SessionManager.TryLink(package.Header.TerminalPhoneNo, socket, receiveMessageFromResult.RemoteEndPoint);
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation($"[Connected]:{receiveMessageFromResult.RemoteEndPoint}");
}
Processor(session, package);
}
catch (NotImplementedException ex)
{
Logger.LogError(ex.Message);
}
catch (JT808Exception ex)
{
Logger.LogError($"[HeaderDeserialize ErrorCode]:{ ex.ErrorCode},[ReaderBuffer]:{buffer.ToArray().ToHexString()}");
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
{
Logger.LogError(ex, $"[ReaderBuffer]:{ buffer.ToArray().ToHexString()}");
}
#pragma warning restore CA1031 // Do not catch general exception types
}
public async Task ReceiveSentMessages_Tasks_Success(bool ipv4)
{
const int DataLength = 1024;
AddressFamily family = ipv4 ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6;
IPAddress loopback = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
using (var receiver = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
using (var sender = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
{
sender.Bind(new IPEndPoint(loopback, 0));
receiver.SetSocketOption(ipv4 ? SocketOptionLevel.IP : SocketOptionLevel.IPv6, SocketOptionName.PacketInformation, true);
int port = receiver.BindToAnonymousPort(loopback);
for (int iters = 0; iters < 5; iters++)
{
sender.SendTo(new byte[DataLength], new IPEndPoint(loopback, port));
SocketReceiveMessageFromResult result = await receiver.ReceiveMessageFromAsync(
new ArraySegment <byte>(new byte[DataLength], 0, DataLength), SocketFlags.None,
new IPEndPoint(ipv4 ? IPAddress.Any : IPAddress.IPv6Any, 0));
Assert.Equal(DataLength, result.ReceivedBytes);
Assert.Equal(sender.LocalEndPoint, result.RemoteEndPoint);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, result.PacketInformation.Address);
}
}
}
public async Task Task_Success(bool ipv4)
{
AddressFamily family = ipv4 ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6;
IPAddress loopback = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
using (Socket receiver = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
using (Socket sender = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(loopback);
receiver.SetSocketOption(ipv4 ? SocketOptionLevel.IP : SocketOptionLevel.IPv6, SocketOptionName.PacketInformation, true);
sender.Bind(new IPEndPoint(loopback, 0));
for (int i = 0; i < TestSettings.UDPRedundancy; i++)
{
sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
}
SocketReceiveMessageFromResult result = await receiver.ReceiveMessageFromAsync(
new ArraySegment <byte>(new byte[1024], 0, 1024), SocketFlags.None,
new IPEndPoint(ipv4 ? IPAddress.Any : IPAddress.IPv6Any, 0));
Assert.Equal(1024, result.ReceivedBytes);
Assert.Equal(sender.LocalEndPoint, result.RemoteEndPoint);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, result.PacketInformation.Address);
}
}
private void ReaderBuffer(ReadOnlySpan <byte> buffer, Socket socket, SocketReceiveMessageFromResult receiveMessageFromResult)
{
try
{
var package = JT1078Serializer.Deserialize(buffer);
package.SIM = package.SIM.TrimStart('0');
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace($"[Accept Hex {receiveMessageFromResult.RemoteEndPoint}]:{buffer.ToArray().ToHexString()}");
}
var session = SessionManager.TryLink(package.SIM, socket, receiveMessageFromResult.RemoteEndPoint);
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation($"[Connected]:{receiveMessageFromResult.RemoteEndPoint}");
}
if (jT1078UseType == JT1078UseType.Queue)
{
jT1078MsgProducer.ProduceAsync(package.SIM, buffer.ToArray());
}
else
{
jT1078PackageProducer.ProduceAsync(package.SIM, package);
}
}
catch (NotImplementedException ex)
{
Logger.LogError(ex.Message);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
{
Logger.LogError(ex, $"[ReaderBuffer]:{ buffer.ToArray().ToHexString()}");
}
#pragma warning restore CA1031 // Do not catch general exception types
}
void Process(Span <byte> octects, SocketReceiveMessageFromResult msg)
{
if (msg.ReceivedBytes < 1)
{
return; // I have no command type to parse... uh!
}
octects = octects[..msg.ReceivedBytes];
private void ReaderBuffer(ReadOnlySpan <byte> buffer, Socket socket, SocketReceiveMessageFromResult receiveMessageFromResult)
{
try
{
var package = Serializer.HeaderDeserialize(buffer, minBufferSize: 10240);
AtomicCounterService.MsgSuccessIncrement();
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug($"[Atomic Success Counter]:{AtomicCounterService.MsgSuccessCount}");
}
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace($"[Accept Hex {receiveMessageFromResult.RemoteEndPoint}]:{package.OriginalData.ToArray().ToHexString()}");
}
var session = SessionManager.TryLink(package.Header.TerminalPhoneNo, socket, receiveMessageFromResult.RemoteEndPoint);
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation($"[Connected]:{receiveMessageFromResult.RemoteEndPoint}");
}
if (JT808UseType == JT808UseType.Normal)
{
JT808NormalReplyMessageHandler.Processor(package, session);
}
else if (JT808UseType == JT808UseType.Queue)
{
MsgProducer.ProduceAsync(package.Header.TerminalPhoneNo, package.OriginalData.ToArray());
}
}
catch (NotImplementedException ex)
{
Logger.LogError(ex.Message);
}
catch (JT808Exception ex)
{
AtomicCounterService.MsgFailIncrement();
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation($"[Atomic Fail Counter]:{AtomicCounterService.MsgFailCount}");
}
Logger.LogError($"[HeaderDeserialize ErrorCode]:{ ex.ErrorCode},[ReaderBuffer]:{buffer.ToArray().ToHexString()}");
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
{
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug($"[Atomic Fail Counter]:{AtomicCounterService.MsgFailCount}");
}
Logger.LogError(ex, $"[ReaderBuffer]:{ buffer.ToArray().ToHexString()}");
}
#pragma warning restore CA1031 // Do not catch general exception types
}
private void ReaderBuffer(ReadOnlySpan <byte> buffer, Socket socket, SocketReceiveMessageFromResult receiveMessageFromResult)
{
try
{
var package = Serializer.HeaderDeserialize(buffer);
AtomicCounterService.MsgSuccessIncrement();
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug($"[Atomic Success Counter]:{AtomicCounterService.MsgSuccessCount}");
}
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace($"[Accept Hex {receiveMessageFromResult.RemoteEndPoint}]:{package.OriginalData.ToArray().ToHexString()}");
}
//设直连模式和转发模式的会话如何处理
string sessionId = SessionManager.TryLink(package.Header.TerminalPhoneNo, socket, receiveMessageFromResult.RemoteEndPoint);
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation($"[Connected]:{receiveMessageFromResult.RemoteEndPoint}");
}
if (Configuration.MessageQueueType == JT808MessageQueueType.InMemory)
{
MsgProducer.ProduceAsync(sessionId, package.OriginalData.ToArray());
}
else
{
MsgProducer.ProduceAsync(package.Header.TerminalPhoneNo, package.OriginalData.ToArray());
}
}
catch (JT808Exception ex)
{
AtomicCounterService.MsgFailIncrement();
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug($"[Atomic Fail Counter]:{AtomicCounterService.MsgFailCount}");
}
Logger.LogError(ex, $"[HeaderDeserialize ErrorCode]:{ ex.ErrorCode}-{buffer.ToArray().ToHexString()}");
}
catch (Exception ex)
{
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug($"[Atomic Fail Counter]:{AtomicCounterService.MsgFailCount}");
}
Logger.LogError(ex, $"[ReaderBuffer]:{ buffer.ToArray().ToHexString()}");
}
}
public async Task ReceiveSent_UDP_Success(bool ipv4)
{
const int Offset = 10;
const int DatagramSize = 256;
const int DatagramsToSend = 16;
IPAddress address = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
using Socket receiver = new Socket(address.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
using Socket sender = new Socket(address.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
receiver.SetSocketOption(ipv4 ? SocketOptionLevel.IP : SocketOptionLevel.IPv6, SocketOptionName.PacketInformation, true);
ConfigureNonBlocking(sender);
ConfigureNonBlocking(receiver);
receiver.BindToAnonymousPort(address);
sender.BindToAnonymousPort(address);
byte[] sendBuffer = new byte[DatagramSize];
var receiveInternalBuffer = new byte[DatagramSize + Offset];
var emptyBuffer = new byte[Offset];
ArraySegment <byte> receiveBuffer = new ArraySegment <byte>(receiveInternalBuffer, Offset, DatagramSize);
Random rnd = new Random(0);
IPEndPoint remoteEp = new IPEndPoint(ipv4 ? IPAddress.Any : IPAddress.IPv6Any, 0);
for (int i = 0; i < DatagramsToSend; i++)
{
rnd.NextBytes(sendBuffer);
sender.SendTo(sendBuffer, receiver.LocalEndPoint);
SocketReceiveMessageFromResult result = await ReceiveMessageFromAsync(receiver, receiveBuffer, remoteEp);
IPPacketInformation packetInformation = result.PacketInformation;
Assert.Equal(DatagramSize, result.ReceivedBytes);
AssertExtensions.SequenceEqual(emptyBuffer, new ReadOnlySpan <byte>(receiveInternalBuffer, 0, Offset));
AssertExtensions.SequenceEqual(sendBuffer, new ReadOnlySpan <byte>(receiveInternalBuffer, Offset, DatagramSize));
Assert.Equal(sender.LocalEndPoint, result.RemoteEndPoint);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, packetInformation.Address);
}
}
public override Task <SocketReceiveMessageFromResult> ReceiveMessageFromAsync(Socket s, ArraySegment <byte> buffer, EndPoint endPoint)
{
var tcs = new TaskCompletionSource <SocketReceiveMessageFromResult>();
SocketFlags socketFlags = SocketFlags.None;
s.BeginReceiveMessageFrom(buffer.Array, buffer.Offset, buffer.Count, socketFlags, ref endPoint, iar =>
{
try
{
int receivedBytes = s.EndReceiveMessageFrom(iar, ref socketFlags, ref endPoint, out IPPacketInformation ipPacketInformation);
var result = new SocketReceiveMessageFromResult
{
ReceivedBytes = receivedBytes,
SocketFlags = socketFlags,
RemoteEndPoint = endPoint,
PacketInformation = ipPacketInformation
};
tcs.TrySetResult(result);
}
catch (Exception e) { tcs.TrySetException(e); }
}, null);
return(tcs.Task);
}
