private void OnTcpServerMessage(ITcpSession session, byte[] data)
{
Message message = Message.Parse(data);
// Logger.trace($"OnTcpServerMessage(): message={message}");
// should route this message?
if (message.ShouldRoute())
{
OnElasticMessage(message);
return;
}
// message sender
Address sender = message.Sender;
// authorized peer?
ElasticAddress peer = Peers.Find(sender);
if (ReferenceEquals(peer, null))
{
Logger.warning($"Unauthorized peer!");
return;
}
// valid sign?
if (!message.Verify(sender))
{
Logger.warning($"Peer signature not verified!");
return;
}
// message handler invoke
OnMessage?.Invoke(peer, message);
}
private void OnHandleAccept(IAsyncResult ar)
{
try
{
// accepted socket
Socket socket = AcceptSocket.EndAccept(ar);
// process accepted socket
OnAcceptSocket(socket);
// begin accept again
BeginAccept();
}
catch (ObjectDisposedException e)
{
Logger.debug($"AcceptSocket.AcceptAsync() canceled! e={e.Message}");
}
catch (SocketException e)
{
Logger.warning($"SocketException! e={e.Message}");
}
catch (Exception e)
{
Logger.error($"Exception! e={e.Message}");
}
}
// Send packet to host
// connect -> send -> close
public static bool SendTo(string host, int port, byte[] data, ILoggable Logger)
{
Debug.Assert(!string.IsNullOrEmpty(host) && data.Length > 0);
// 패킷 최대 크기
Debug.Assert(data.Length < TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE);
if (data.Length > TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE)
{
Logger.warning($"exceeds MAX_PACKET_SIZE({TcpSession.MAX_PACKET_SIZE})");
return(false);
}
System.Net.Sockets.TcpClient tcp_client = null;
try
{
tcp_client = new System.Net.Sockets.TcpClient(host, port);
}
catch (Exception e)
{
Logger.error($"can't connect to Peer! remote={host}:{port}, e={e.Message}");
return(false);
}
// 전송할 데이터
List <byte> bytes = new List <byte>();
bytes.AddRange(BitConverter.GetBytes(data.Length));
bytes.AddRange(data);
byte[] bytesToSend = bytes.ToArray();
bool ret = false;
try
{
// write data to socket
NetworkStream ns = tcp_client.GetStream();
ns.Write(bytesToSend, 0, bytesToSend.Length);
ret = true;
}
catch (Exception e)
{
Logger.error($"can't write to peer! remote={host}:{port}, data.Length={data.Length}, e={e.Message}");
}
finally
{
// 소켓 종료
tcp_client.Close();
}
return(ret);
}
// Send packet to host
// connect -> send -> close
public static bool SendTo(byte[] data, string host, int port, ILoggable logger)
{
Debug.Assert(!string.IsNullOrEmpty(host) && data.Length > 0);
// 패킷 최대 크기
Debug.Assert(data.Length < TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE);
if (data.Length > TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE)
{
logger.error($"exceeds MAX_PACKET_SIZE({TcpSession.MAX_PACKET_SIZE})");
return(false);
}
// connect to host
TcpClient client = null;
try
{
client = new TcpClient(host, port);
}
catch (Exception e)
{
logger.warning($"can't connect to Peer! remote={host}:{port}, e={e.Message}");
return(false);
}
// write to host
try
{
byte[] bytesToSend = BitConverter.GetBytes(data.Length).Merge(data);
client.GetStream().Write(bytesToSend, 0, bytesToSend.Length);
return(true);
}
catch (Exception e)
{
logger.error($"can't write to peer! remote={host}:{port}, data.Length={data.Length}, e={e.Message}");
}
finally
{
client.Close();
}
return(false);
}
public void OnConsoleCommand(string command, string[] args)
{
switch (command.ToLower())
{
case "quit":
case "shutdown":
case "exit": OnConsoleCommandExit(args); break;
case "h":
case "help": ShowUsage(); break;
case "set": OnConsoleCommandSet(args); break;
case "env": ShowEnviromentValues(); break;
case "cls": ClearScreen(); break;
case "test.start": OnConsoleCommandTestStart(args); break;
case "test.prepare": OnConsoleCommandTestPrepare(args); break;
case "test.run": OnConsoleCommandTestRun(args); break;
case "test.stop": OnConsoleCommandTestStop(args); break;
case "test.report": OnConsoleCommandTestReport(args); break;
case "test.clear": OnConsoleCommandTestClear(args); break;
case "peers": OnConsoleCommandPeersList(args); break;
case "peers.sync": OnConsoleCommandPeersSync(args); break;
case "peers.layout": OnConsoleCommandPeersLayout(args); break;
case "peers.kill": OnConsoleCommandPeersKill(args); break;
default: Logger.warning("unknown command!\r\n: type 'h' for command list."); break;
}
}
public void OnConsoleCommand(string command, string[] args)
{
switch (command.ToLower())
{
case "quit":
case "shutdown":
case "exit": OnConsoleCommandExit(args); break;
case "h":
case "help": ShowUsage(); break;
case "set": OnConsoleCommandSet(args); break;
case "env": ShowEnv(); break;
case "cls": ClearScreen(); break;
case "peers.sync": OnConsoleCommandPeersSync(args); break;
case "peers.layout": OnConsoleCommandPeersLayout(args); break;
case "peers": OnConsoleCommandPeers(args); break;
default: Logger.warning($"unknown command!\r\n: type 'h' for command list"); break;
}
}
// Send packet to host and receive data
// connect -> send -> read -> close
public static byte[] SendToAndReceive(byte[] data, string host, int port, ILoggable logger)
{
Debug.Assert(!string.IsNullOrEmpty(host) && data.Length > 0);
// 패킷 최대 크기
Debug.Assert(data.Length < TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE);
if (data.Length > TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE)
{
logger.error($"exceeds MAX_PACKET_SIZE({TcpSession.MAX_PACKET_SIZE})");
return(null);
}
// connect to host
TcpClient client = null;
try
{
client = new TcpClient(host, port);
}
catch (Exception e)
{
logger.warning($"can't connect to Peer! remote={host}:{port}, e={e.Message}");
return(null);
}
// write to host
try
{
byte[] bytesToSend = BitConverter.GetBytes(data.Length).Merge(data);
client.GetStream().Write(bytesToSend, 0, bytesToSend.Length);
}
catch (Exception e)
{
logger.error($"can't write to peer! remote={host}:{port}, data.Length={data.Length}, e={e.Message}");
client.Close();
return(null);
}
// read ack
try
{
List <byte> bytesAck = new List <byte>();
byte[] bytesToRead = new byte[TcpSession.HEADER_SIZE];
byte[] buffer = new byte[8 * 1024];
NetworkStream ns = client.GetStream();
// read header
int reads = ns.Read(bytesToRead, 0, TcpSession.HEADER_SIZE);
Debug.Assert(reads == TcpSession.HEADER_SIZE);
int header = BitConverter.ToInt32(bytesToRead, 0);
Debug.Assert(header > 0 && header < TcpSession.MAX_PACKET_SIZE);
// read data
while (bytesAck.Count < header)
{
reads = ns.Read(buffer, 0, buffer.Length);
if (reads <= 0)
{
break;
}
bytesAck.AddRange(reads == buffer.Length?buffer:buffer.Take(reads).ToArray());
}
return(bytesAck.ToArray());
}
catch (Exception e)
{
logger.error($"can't read from peer! remote={host}:{port}, e={e.Message}");
}
finally
{
client.Close();
}
return(null);
}
public void OnTcpConnectFail(ITcpClient client, string err)
{
Logger.warning("can't connect to PeerListService", err);
}
