namespace bts { using BCG; using BCG.Utilities.General; using System; using System.IO; using System.Net.Sockets; using System.Threading.Tasks; using System.Threading; using System.Net; using System.Text; // this ITCPConnection uses the TCPClient class instead of a raw socket (in the hope, that it would configure the socket correctly) public class AsyncTCPConnection_AsyncWrapper : ITCPConnection, IWorker, IDisposable { public class ConnectionID { public readonly RemoteConnectionInfo self; public readonly RemoteConnectionInfo peer; public readonly Type conn_type; public override string ToString() { return $"{conn_type} self: {self} peer: {peer}"; } public ConnectionID(RemoteConnectionInfo self_, RemoteConnectionInfo peer_, Type conn_type_) { self = self_; peer = peer_; conn_type = conn_type_; } } private const int DATA_MSG_SIGNAL = 0; private const int HB_MSG_SIGNAL = 1; private TcpClient _tcp_client; private NetworkStream _nw_stream; private ITCPMessageHandler _msg_handler; private bool _is_alive = true; ConnectionID _connection_id; public static string to_hex(byte[] byte_arr, int start_pos, int end_pos) { var len = end_pos - start_pos; StringBuilder hex_builder = new StringBuilder(len * 2); int i = 0; foreach (byte b in byte_arr) { if (i >= start_pos && i < end_pos) hex_builder.Append($"{b:X2} "); i++; } return hex_builder.ToString().Trim(); } public AsyncTCPConnection_AsyncWrapper(TcpClient tcp_client) { _tcp_client = tcp_client; _nw_stream = _tcp_client.GetStream(); _connection_id = new ConnectionID(TCPSocketUtils.get_self_address(_tcp_client.Client), TCPSocketUtils.get_peer_address(_tcp_client.Client), GetType()); Log.Gen.info($"AsyncTCPConnection_AsyncWrapper.cons connection: {_connection_id}"); } private void _detect_connection_status_change() { Action testing_func = () => { bool connected = _tcp_client.Connected; while (true) { if (connected != _tcp_client.Connected) Log.Gen.error($"Connection status changed this: {ToString()} {connected} -> {_tcp_client.Connected}"); connected = _tcp_client.Connected; System.Threading.Thread.Sleep(50); if (!connected) break; } }; ThreadPool.QueueUserWorkItem(_ => testing_func()); } #region Sending public void _send_fixed_size_msg(byte[] buffer) { string buff_txt = to_hex(buffer, 0, buffer.Length); Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._send_fixed_size_msg buffer: {buff_txt}"); int total_bytes_sent = 0; int n_bytes = buffer.Length; int n_transfers = 0; while (_is_alive && total_bytes_sent < n_bytes) { int remaining_bytes = n_bytes - total_bytes_sent; _nw_stream.Write(buffer, total_bytes_sent, remaining_bytes); total_bytes_sent += remaining_bytes; n_transfers++; } Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._send_fixed_size_msg sent {buffer.Length} bytes in {n_transfers} transfers"); } private void _send_one_msg(byte[] msg) { try { // the total msg = [msg_sz, msg_type, data] int sz = msg.Length + 4; MemoryStream str = new MemoryStream(); BinaryWriter bw = new BinaryWriter(str); bw.Write(sz); bw.Write(DATA_MSG_SIGNAL); bw.Write(msg); str.Position = 0; byte[] buff = str.ToArray(); _send_fixed_size_msg(buff); } catch (Exception ex) { _handle_error(new ErrorMessage(ex, $"_send_one_msg call_stacK: {ex.StackTrace}")); } } private void _send_forever() { while (_is_alive) { byte[] data = _send_queue.dequeue(); if (data != null) { _send_one_msg(data); } } } private SyncQueue _send_queue = new SyncQueue(); public void send(byte[] data) { var data_txt = to_hex(data, 0, data.Length); Log.Gen.info($"AsyncTCPConnection_AsyncWrapper.send data: {data_txt}"); //Task.Run(() => _send_one_msg(data)); //ThreadPool.QueueUserWorkItem(_ => _send_one_msg(data)); _send_queue.enqueue(data); } #endregion public void register(ITCPMessageHandler message_handler) { _msg_handler = message_handler; // starting thread pool threads to keep reading and sending ThreadPool.QueueUserWorkItem(_ => _read_msgs_forever()); ThreadPool.QueueUserWorkItem(_ => _send_forever()); } public RemoteConnectionInfo get_peer_address() { return _connection_id.peer; } public RemoteConnectionInfo get_self_address() { return _connection_id.self; } public bool isDisposed { get { return !_is_alive; } } public void doWork() { // send hb } #region Reading // This makes the blocking IO call, the callstack is _read_msgs_forever -> _read_one_message -> _read_fixed_size_msg private byte[] _read_fixed_size_msg(int n_bytes) { if (n_bytes <= 0) { throw new ArgumentException("Number of bytes to read must be greater than zero.", nameof(n_bytes)); } byte[] buffer = new byte[n_bytes]; int total_bytes_read = 0; int n_transfers = 0; while (_is_alive && total_bytes_read < n_bytes) { int bytes_read = _nw_stream.Read(buffer, total_bytes_read, n_bytes - total_bytes_read); if (bytes_read <= 0) { throw new IOException("Read 0 bytes, the connection was closed before all data could be read."); } n_transfers++; total_bytes_read += bytes_read; Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._read_fixed_size_msg n_bytes: {n_bytes} bytes_read: {bytes_read} total_bytes_read: {total_bytes_read} buff_len: {buffer.Length}"); } Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._read_fixed_size_msg read {n_bytes} bytes in {n_transfers} transfers"); return buffer; } private class OneRecvMessage { public int msg_type; public byte[] data; public OneRecvMessage(int msg_type_, byte[] data_) { msg_type = msg_type_; data = data_; } public OneRecvMessage(byte[] msg) { MemoryStream str = new MemoryStream(msg); BinaryReader br = new BinaryReader(str); int msg_type = br.ReadInt32(); if (msg_type == DATA_MSG_SIGNAL) { // TODO, polish it, too much memory bneing allocated data = br.ReadBytes(msg.Length - 4); } } public override string ToString() { string rv = $"OneMessage msg_type: {msg_type} data_len: {data.Length}"; return rv; } } private OneRecvMessage _read_one_message() { // read size first byte[] sz_arr = _read_fixed_size_msg(4); BinaryReader br = new BinaryReader(new MemoryStream(sz_arr)); br.BaseStream.Position = 0; int msg_sz = br.ReadInt32(); Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._read_one_message read msg_sz: {msg_sz}"); if (msg_sz < 0) { throw new IOException("Read 0 bytes, the connection was closed before all data could be read."); } byte[] msg = _read_fixed_size_msg(msg_sz); Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._read_one_message read msg sz: {msg.Length}"); // TODO, read first 4 bytes and decide hb or data OneRecvMessage rv = new OneRecvMessage(msg); return rv; } private void _read_msgs_forever() { while (_is_alive) { try { OneRecvMessage one_msg = _read_one_message(); if (one_msg.msg_type == DATA_MSG_SIGNAL) { _msg_handler.onData(new RemoteMessage(one_msg.data, RemoteMessageType.Data, _connection_id.peer)); } else if (one_msg.msg_type == HB_MSG_SIGNAL) { // keep a last hb time an dudpate it here atomically _msg_handler.onData(new RemoteMessage(null, RemoteMessageType.Heartbeat, _connection_id.peer)); } else { throw new ApplicationException($"Unknown message type: {one_msg.msg_type}"); } } catch (Exception ex) { _handle_error(new ErrorMessage(ex, $"_read_msgs_forever, call_stack: {ex.StackTrace}")); } } Log.Gen.info($"AsyncTCPConnection_AsyncWrapper._read_msgs_forever exiting loop"); } #endregion public bool is_disposed => !_is_alive; public class ErrorMessage { public readonly SocketError? socket_error = null; public readonly Exception exception = null; public readonly bool is_exception = false; public readonly string context = String.Empty; public ErrorMessage(SocketError socket_error_, string context_) { socket_error = socket_error_; context = context_; } public ErrorMessage(Exception exception_, string context_) { is_exception = true; exception = exception_; context = context_; } public bool oom => exception != null && exception is OutOfMemoryException; public override string ToString() { if (is_exception) return $"ErrorMessage exception: {exception} context: {context}"; return $"socket_error: {socket_error} context: {context}"; } } public void Dispose() { // socket is closed and disposed here lock (this) { if (_is_alive) { //_master_worker.removeWorker(this); _is_alive = false; try { bts.Log.Gen.info($"AsyncTCPConnection_APM.Dispose this: {this} closing tcp_client nin an orderly fashion now"); _tcp_client.Close(); } catch (Exception ex) { String.Format("AsyncTCPConnection_APM.Dispose exception: {ex} thrown when closing socket"); if (ex is OutOfMemoryException) throw ex; } _msg_handler.onData(new RemoteMessage(null, RemoteMessageType.Disconnection, _connection_id.peer)); } } } private void _handle_error(ErrorMessage err_msg) { lock (this) { Log.Gen.error($"AsyncTCPConnection_APM._handle_error this: {this} error_msg: {err_msg}"); if (err_msg.oom) throw err_msg.exception; Dispose(); } } public override string ToString() { return _connection_id.ToString(); } } }