296 lines
8.7 KiB
C#
296 lines
8.7 KiB
C#
using BCG;
|
|
|
|
using Google.Protobuf;
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using BCG;
|
|
using System.Xml.Serialization;
|
|
using System.Reflection;
|
|
using BCG.Utilities.General;
|
|
using System.Net.WebSockets;
|
|
|
|
namespace BCG
|
|
{
|
|
|
|
public class AsyncTCPConnection2 : ITCPConnection, IWorker, IDisposable
|
|
{
|
|
//private Socket _socket;
|
|
// tied to the socket above
|
|
private NetworkStream _nw_stream;
|
|
private readonly ConnectionSide _side;
|
|
ITCPMessageHandler _message_handler;
|
|
private int _msg_id = 0;
|
|
RemoteConnectionInfo _peer_address;
|
|
RemoteConnectionInfo _self_address;
|
|
private TimeSpan _hb_period = TimeSpan.FromSeconds(1);
|
|
private DateTime _last_hb_sent = DateTime.MinValue;
|
|
private DateTime _last_hb_received = DateTime.MaxValue;
|
|
private static byte _msg_type_data = 1;
|
|
private static byte _msg_type_hb = 0;
|
|
private bool _is_disposed = false;
|
|
SyncQueue<QueuedMessage> _data_send_queue = new SyncQueue<QueuedMessage>();
|
|
|
|
public class QueuedMessage
|
|
{
|
|
public string id;
|
|
public SendConfirmationDelegate del;
|
|
public byte[] data;
|
|
|
|
public QueuedMessage(string id, SendConfirmationDelegate del, byte[] data)
|
|
{
|
|
id = id;
|
|
del = del;
|
|
data = data;
|
|
}
|
|
|
|
public QueuedMessage(byte[] data)
|
|
: this(String.Empty, null, data) { }
|
|
|
|
}
|
|
|
|
public enum ConnectionSide
|
|
{
|
|
Client,
|
|
Server
|
|
}
|
|
|
|
public AsyncTCPConnection2(Socket socket, ConnectionSide side)
|
|
{
|
|
//_socket = socket;
|
|
_nw_stream = new NetworkStream(socket);
|
|
_side = side;
|
|
IPEndPoint r_ep = socket.RemoteEndPoint as IPEndPoint;
|
|
_peer_address = new RemoteConnectionInfo(r_ep.Address.ToString(), r_ep.Port);
|
|
|
|
var loc_ep = socket.LocalEndPoint as IPEndPoint;
|
|
_self_address = new RemoteConnectionInfo(loc_ep.Address.ToString(), loc_ep.Port);
|
|
}
|
|
|
|
public void register(ITCPMessageHandler message_handler)
|
|
{
|
|
_message_handler = message_handler;
|
|
Task.Run(async () => _keep_reading());
|
|
Task.Run(async () => await _keep_sending());
|
|
//_keep_reading();
|
|
// if add a _keep_sending threadis added then we can maek send a non async
|
|
// methid making it much easier to integrate with the rest
|
|
}
|
|
|
|
// this thread pulls
|
|
private async Task _keep_sending()
|
|
{
|
|
bts.Log.Gen.info($"TCPConnection._keep_sending starting");
|
|
while (!_is_disposed)
|
|
{
|
|
try
|
|
{
|
|
QueuedMessage m = _data_send_queue.dequeue(100);
|
|
if (m == null)
|
|
{
|
|
continue;
|
|
}
|
|
await send_async(m.data);
|
|
if (String.IsNullOrEmpty(m.id))
|
|
{
|
|
m.del(m.id, true);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
bts.Log.Gen.error($"TCPConnection._keep_sending ex: {ex.Message}");
|
|
await Task.Delay(100);
|
|
_handle_error(ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task _keep_reading()
|
|
{
|
|
bts.Log.Gen.info($"TCPConnection._keep_reading starting");
|
|
while (!_is_disposed)
|
|
{
|
|
try
|
|
{
|
|
byte[] msg = await TCPSocketUtils.read_bytes_async(_nw_stream);
|
|
bts.Log.Gen.info($"AsyncTCPConnection2._keep_reading side: {_side} self: {get_self_address()} peer: {get_peer_address()} msg len: {msg.Length}");
|
|
await _handle_msg(msg);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
bts.Log.Gen.error($"TCPConnection._keep_reading ex: {ex.Message}");
|
|
await Task.Delay(100);
|
|
_handle_error(ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task _handle_msg(byte[] msg)
|
|
{
|
|
// read the first byte to read the msg type and deal with it accordingly
|
|
BinaryReader br = new BinaryReader(new MemoryStream(msg));
|
|
byte msg_type = br.ReadByte();
|
|
if (msg_type == _msg_type_data)
|
|
{
|
|
byte[] data = br.ReadBytes(msg.Length - 1);
|
|
RemoteMessage m = new RemoteMessage(data, RemoteMessageType.Data, _peer_address);
|
|
_message_handler.onData(m);
|
|
}
|
|
else
|
|
{
|
|
RemoteMessage m = new RemoteMessage(null, RemoteMessageType.Heartbeat, _peer_address);
|
|
_message_handler.onData(m);
|
|
}
|
|
}
|
|
|
|
// not very efficient
|
|
private static byte[] _prefix_msg_type(byte[] data)
|
|
{
|
|
MemoryStream ms = new MemoryStream();
|
|
BinaryWriter bw = new BinaryWriter(ms);
|
|
bw.Write(_msg_type_data);
|
|
bw.Write(data);
|
|
ms.Position = 0;
|
|
return ms.ToArray();
|
|
}
|
|
|
|
private async void _handle_error(Exception ex)
|
|
{
|
|
bts.Log.Gen.error($"TCPConnection._handle_error ex: {ex}");
|
|
try
|
|
{
|
|
var socket = _nw_stream.Socket;
|
|
socket.Close();
|
|
socket.Dispose();
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
bts.Log.Gen.error($"TCPConnection._handle_error got exception when closing Socket ex: {ex}");
|
|
}
|
|
_is_disposed = true;
|
|
RemoteMessage rm = new RemoteMessage(new byte[] { }, RemoteMessageType.Disconnection, _peer_address);
|
|
_message_handler.onData(rm);
|
|
}
|
|
|
|
public void send_with_confirmation(byte[] data, string confId, SendConfirmationDelegate del) { }
|
|
|
|
public async Task send_with_confirmation_async(byte[] data, string conf_id, SendConfirmationDelegate del)
|
|
{
|
|
try
|
|
{
|
|
conf_id = (++_msg_id).ToString();
|
|
await TCPSocketUtils.send_bytes_async(_nw_stream, data);
|
|
del(conf_id, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_handle_error(ex);
|
|
}
|
|
}
|
|
|
|
public void sendWithConfirmation(byte[] data, ref string conf_id, SendConfirmationDelegate del)
|
|
{
|
|
conf_id = (++_msg_id).ToString();
|
|
send(data);
|
|
del(conf_id, true);
|
|
}
|
|
|
|
public void send(byte[] data)
|
|
{
|
|
Task.Run(async () => await send_async(data));
|
|
bts.Log.Gen.info($"AsyncTCPConnection2.send self: {get_self_address()} peer: {get_peer_address()} msg len: {data.Length} sent successfully");
|
|
//_data_send_queue.enqueue(new QueuedMessage(data));
|
|
}
|
|
|
|
public async Task send_async(byte[] data)
|
|
{
|
|
// prefix 4 bytes for type (data vs hb)
|
|
MemoryStream str = new MemoryStream();
|
|
BinaryWriter bw = new BinaryWriter(str);
|
|
bw.Write(_msg_type_data);
|
|
bw.Write(data);
|
|
try
|
|
{
|
|
await TCPSocketUtils.send_bytes_async(_nw_stream, str.ToArray());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
bts.Log.Gen.error($"AsyncTCPConnection2.send_async ex: {ex}");
|
|
_handle_error(ex);
|
|
}
|
|
}
|
|
|
|
public void getPeerAddress(out string ip, out int port)
|
|
{
|
|
ip = _peer_address.ip;
|
|
port = _peer_address.port;
|
|
///.Net has some problems getting the port, so using
|
|
///native code for that
|
|
//sockaddr addr = new sockaddr();
|
|
//int namelen = 16;
|
|
//getsockname(mySock.Handle, ref addr, ref namelen);
|
|
//port = addr.sin_port;
|
|
}
|
|
|
|
public RemoteConnectionInfo get_peer_address()
|
|
{
|
|
string ip; int port;
|
|
getPeerAddress(out ip, out port);
|
|
return new RemoteConnectionInfo(ip, port);
|
|
}
|
|
|
|
public RemoteConnectionInfo get_self_address()
|
|
{
|
|
string ip; int port;
|
|
getSelfAddress(out ip, out port);
|
|
return new RemoteConnectionInfo(ip, port);
|
|
}
|
|
|
|
|
|
public void getSelfAddress(out string ip, out int port)
|
|
{
|
|
ip = _self_address.ip;
|
|
port = _self_address.port;
|
|
}
|
|
|
|
private async void _send_hb()
|
|
{
|
|
if (_last_hb_sent - DateTime.Now > _hb_period)
|
|
{
|
|
MemoryStream ms = new MemoryStream();
|
|
BinaryWriter bw = new BinaryWriter(ms);
|
|
bw.Write(_msg_type_hb);
|
|
ms.Position = 0;
|
|
byte[] hb_msg = ms.ToArray();
|
|
await TCPSocketUtils.send_bytes_async(_nw_stream, hb_msg);
|
|
}
|
|
}
|
|
|
|
public void doWork()
|
|
{
|
|
_send_hb();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_nw_stream.Close();
|
|
_nw_stream.Dispose();
|
|
_is_disposed = true;
|
|
}
|
|
|
|
public bool isDisposed
|
|
{
|
|
get
|
|
{
|
|
return _is_disposed;
|
|
}
|
|
}
|
|
|
|
}
|
|
} |