public NetUnit(int bufferSize = 1024, int port = 11000)
{
try
{
allDone = new ManualResetEvent(false);
this.bufferSize = bufferSize;
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
mySocket = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
mySocket.Bind(localEndPoint);
mySocket.Listen(200);
connectionManager = new ConnectionManager();
logger.Info("Server started!");
new Thread(Listen).Start();
}
catch (Exception exception)
{
logger.Error(exception);
}
}
public void Startup()
{
if (CurrentState != ServiceState.Stopped)
{
return;
}
try {
_Startup();
RuntimeErrorMessage = null;
_started = true;
enabled = true;
ULogger.Info($"Service {serviceName} started");
Started.Trigger();
} catch (Exception e) {
// 启动服务失败，若设置了自动重启间隔，则在指定间隔后尝试重启
RuntimeErrorMessage = $"{e.GetType ().Name}: {e.Message}";
_started = false;
enabled = false;
ULogger.Warning(
$"Start service {serviceName} failed due to {RuntimeErrorMessage}");
if (retryInterval != 0)
{
Invoke(nameof(Startup), retryInterval);
}
}
}
public bool Send(Packet.Packet packet)
{
try {
if (!IsRunning)
{
throw new ServiceException($"{serviceName} is not running.");
}
if (_client == null || !_client.Connected)
{
throw new ServiceException($"{serviceName} is not in connection.");
}
var packetData = packet.Data;
var packetCode = _packetForwardService.GetPacketCode(typeof(T));
var writer = new _NetWriter(packetCode, packetData);
writer.WriteNextSubPacket(new BinaryWriter(_client.GetStream()));
if (showLog)
{
ULogger.Info($"<{serviceName}> {packet.GetType ().FullName} was sent.");
}
return(true);
} catch (Exception e) {
ULogger.Warning($"<{serviceName}> Send {packet.GetType ().FullName} failed.", e);
return(false);
}
}
public bool Send(Packet.Packet packet)
{
try {
if (!IsRunning)
{
throw new ServiceException($"{serviceName} is not running.");
}
var remoteEp = new IPEndPoint(IPAddress.Parse(remoteIP), remotePort);
var packetData = packet.Data;
var packetCode = _packetForwardService.GetPacketCode(packet.GetType());
var writer = new _NetWriter(packetCode, packetData, _seq);
while (true)
{
try {
_buffStream.Seek(0, SeekOrigin.Begin);
var bytesWritten =
writer.WriteNextSubPacket(new BinaryWriter(_buffStream));
_client.Send(_buffStream.GetBuffer(), (int)bytesWritten, remoteEp);
} catch (EndOfStreamException) {
break;
}
}
if (showLog)
{
ULogger.Info($"<{serviceName}> {packet.GetType ().FullName} was sent.");
}
return(true);
} catch (Exception e) {
ULogger.Warning($"<{serviceName}> Send {packet.GetType ().FullName} failed.", e);
return(false);
}
}
private void _CheckConnectionState()
{
// This is how you can determine whether a socket is still connected.
var blockingState = _client.Client.Blocking;
try {
_client.Client.Blocking = false;
Send(new _TcpCheckPacket());
if (showLog)
{
ULogger.Info($"<{serviceName}> Send _TcpCheckPacket.");
}
} catch (SocketException e) {
Debug.Log(e);
// 10035 == WSAEWOULDBLOCK
if (!e.NativeErrorCode.Equals(10035))
{
_HandleConnectionClosedByRemote();
}
} finally {
if (_client != null)
{
_client.Client.Blocking = blockingState;
}
}
}
public void Resume()
{
if (CurrentState != ServiceState.Paused)
{
return;
}
enabled = true;
ULogger.Info($"Service {serviceName} resumed");
Resumed.Trigger();
}
public void Pause()
{
if (CurrentState != ServiceState.Running)
{
return;
}
enabled = false;
ULogger.Info($"Service {serviceName} paused");
Paused.Trigger();
}
private void _AcceptConnectionToClient()
{
_client = _listener.AcceptTcpClient();
_listener.Stop();
_lastCheckTime = Time.realtimeSinceStartup;
var clientEP = (IPEndPoint)_client.Client.RemoteEndPoint;
ULogger.Info(
$"<{serviceName}> Client has been connected: {clientEP.Address}:{clientEP.Port}.");
}
public void Start(int bufferSize, int port = 11000)
{
try
{
_logger = new ULogger();
_bufferSize = bufferSize;
_allDone = new ManualResetEvent(false);
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
Socket listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
listener.Bind(localEndPoint);
listener.Listen(200);
_serverIsRunning = true;
_logger.Info("Server started!");
while (true)
{
_allDone.Reset();
_logger.Info("Waiting for connection...");
listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
_allDone.WaitOne();
}
}
catch (Exception exception)
{
_logger.Error(exception);
throw exception;
}
}
private void _HandleConnectionClosedByRemote(_TcpClosePacket packet = null)
{
ULogger.Info(packet != null ?
$"<{serviceName}> Connection closed by remote." :
$"<{serviceName}> Connection to remote is lost.");
_client.Dispose();
_client = null;
Shutdown();
if (retryInterval > 0)
{
Startup();
}
}
private void _CloseConnectionToClient(_TcpClosePacket packet = null)
{
if (packet != null)
{
ULogger.Info($"<{serviceName}> Close connection to client.");
Send(new _TcpClosePacket());
}
else
{
ULogger.Info($"<{serviceName}> Connection to client is closed.");
}
_client.Dispose();
_client = null;
_listener.Start();
Disconnected.Trigger();
}
public void Shutdown()
{
if (CurrentState == ServiceState.Stopped)
{
return;
}
try {
_Shutdown();
} catch (Exception) {
// ignored
}
RuntimeErrorMessage = null;
_started = false;
enabled = false;
ULogger.Info($"Service {serviceName} stopped");
Stopped.Trigger();
}
protected override void _Update()
{
if (_client == null)
{
if (_listener.Pending())
{
_AcceptConnectionToClient();
}
return;
}
if (Time.realtimeSinceStartup - _lastCheckTime > CONN_CHECK_INTERVAL * 5)
{
ULogger.Info($"<{serviceName}> Connection is timeout.");
_CloseConnectionToClient();
return;
}
_Receive();
}
private void _UDPRead()
{
while (_client.Available != 0)
{
// 接收来自远程主机的数据子包，并获取来源地址
var remoteEP = new IPEndPoint(IPAddress.Any, localPort);
var data = _client.Receive(ref remoteEP);
// [LOG] UDP data length
if (showLog)
{
ULogger.Info($"<{serviceName}> Udp data received, length = {data.Length}");
}
// 获取或创建与远程主机绑定的数据包读取对象
if (!_netReaders.TryGetValue(remoteEP, out var netReader))
{
_netReaders.Add(remoteEP, netReader = _NetReader.Create(NetType.UDP));
}
// 读取并尝试组装子包
_RawPacket rawPacket;
try {
rawPacket = netReader.Read(new BinaryReader(new MemoryStream(data)),
data.Length);
} catch (Exception e) {
ULogger.Warning(
$"<{serviceName}> Received unrecognized or corrupted packet", e);
continue;
}
if (rawPacket == null)
{
continue;
}
// 填入远程主机地址并分发数据包
rawPacket.remoteEP = remoteEP;
_packetForwardService.ForwardPacket(rawPacket);
}
}
public void EditorInfo(object message)
{
innerLogger.Info(message);
}