Merging, and adding test project

This commit is contained in:
Taha authored and John Colvin committed 2023-09-30 12:52:37 -04:00
1 parent 9311c27f47
commit 404698152e
13 files changed
+717 -110

No files matched your search

@@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net7.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
<PackageReference Include="NUnit" Version="3.13.3" />
<PackageReference Include="NUnit3TestAdapter" Version="4.3.0" />
<PackageReference Include="NUnit.Analyzers" Version="3.5.0" />
<PackageReference Include="coverlet.collector" Version="3.1.2" />
</ItemGroup>
</Project>
@@ -0,0 +1,15 @@
namespace DataStreamTests;
public class Tests
{
[SetUp]
public void Setup()
{
}
[Test]
public void Test1()
{
Assert.Pass();
}
}
@@ -0,0 +1 @@
global using NUnit.Framework;
@@ -0,0 +1,132 @@
using System;
using System.Linq.Expressions;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using Spark.Core.Reactive;
using System.Security.Cryptography.X509Certificates;
using BCG;
namespace BCG
{
// This uses AsyncTCPConnection2's stateful async functions
public class SimpleTCPClientAsync : ITCPConnectionHandler, ITCPMessageHandler
{
AsyncTCPConnection2 _conn = null;
int _m_msgs_received = 0;
public static async Task start(string ip, int port)
{
SimpleTCPClientAsync c = new SimpleTCPClientAsync(ip, port);
c.connect();
}
public void connect()
{
Task.Run(async () => await TCPSocketUtils.connect_to_server_async("127.0.0.1", 12345, this, TimeSpan.FromSeconds(2)));
}
public void onConnection(ITCPConnection connection)
{
Console.WriteLine("SimpleTCPClientAsync.onConnection connected to server, starting task to send data in a loop");
connection.register(this);
// start sending data
Task.Run(async () =>
{
byte[] buff = new byte[1024];
for (int i = 0; i < buff.Length; i++)
{
buff[i] = (byte)i;
}
_conn = connection as AsyncTCPConnection2;
while (!_conn.isDisposed)
{
await _conn.send_async(buff);
await Task.Delay(100);
}
});
}
public void onData(RemoteMessage msg)
{
_m_msgs_received++;
Console.WriteLine($"SimpleTCPClientAsync.onData n_msgs: {_m_msgs_received} msg: {msg}");
if (msg.messageType == RemoteMessageType.disconnection)
{
connect();
}
}
public bool isDisposed { get { return false; } }
public void Dispose() { }
public SimpleTCPClientAsync(string ip, int port) { }
}
public class SimpleTCPClient : ITCPConnectionHandler, ITCPMessageHandler
{
private int _n_msgs_received = 0;
AsyncTCPConnection2 _conn = null;
public static void start(string ip, int port)
{
SimpleTCPClient c = new SimpleTCPClient(ip, port);
c.connect();
}
public void connect()
{
Console.WriteLine("SimpleTCPClient.onConnection connect() called");
ClientToServerManagedTCPConnector.connect_to(new BlutoSubAddress("bluto://127.0.0.1:12345"), this, TimeSpan.FromSeconds(1));
}
public void onConnection(ITCPConnection connection)
{
_conn = connection as AsyncTCPConnection2;
Console.WriteLine("SimpleTCPClient.onConnection connected to server, starting task to send data in a loop");
_conn.register(this);
byte[] buff = new byte[1024];
for (int i = 0; i < buff.Length; i++)
{
buff[i] = (byte)i;
}
while (!_conn.isDisposed)
{
_conn.send(buff);
System.Threading.Thread.Sleep(100);
}
// Task.Run(async () =>
// {
// while (!_conn.isDisposed)
// {
// await _conn.send_async(buff);
// await Task.Delay(100);
// }
// });
}
public void onData(RemoteMessage msg)
{
_n_msgs_received++;
Console.WriteLine($"SimpleTCPClient.onData messages received: {_n_msgs_received} msg: {msg} messages received: {_n_msgs_received}");
if (msg.messageType == RemoteMessageType.disconnection)
{
connect();
}
}
public bool isDisposed { get { return false; } }
public void Dispose() { }
public SimpleTCPClient(string ip, int port) { }
}
}
@@ -0,0 +1,231 @@
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 () => await _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);
//Console.WriteLine($"_keep_reading sz: {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 confId, SendConfirmationDelegate del) {
confId = String.Empty;
}
public void send(byte[] data) {
Task.Run(async () => await send_async(data));
//_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 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() {
}
public bool isDisposed {
get {
return _is_disposed;
}
}
}
}
@@ -4,21 +4,19 @@ using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
//using BCG.Utilities;
//using BCG.Utilities.General;
namespace BCG
{
internal class SocketConnectionArgs
{
namespace BCG {
internal class SocketConnectionArgs {
public EndPoint ep;
public Socket sock;
public ITCPConnectionHandler handler;
public string serverURL;
internal SocketConnectionArgs(EndPoint theEp, Socket theSock, ITCPConnectionHandler theHandler,
string theServerURL)
{
string theServerURL) {
ep = theEp;
sock = theSock;
handler = theHandler;
@@ -26,46 +24,46 @@ namespace BCG
}
}
public class ClientToServerManagedTCPConnector
{
public class ClientToServerManagedTCPConnector {
private static Random myRnd = new Random(DateTime.Now.Millisecond);
private static TimeSpan myHBTimeSpan = new TimeSpan(0, 0, 0, 0, PubSub3Config.instance.PS3_HeartBeatInterval);
private static int myWaitTimeBeforeRetryingUpperLimit = 5000,
myWaitTimeBeforeRetryingLowerLimit = 1000;
public static void connectTo(BlutoSubAddress serverAddress, ITCPConnectionHandler handler)
{
// TODOds
// BlueEventLog.logEvent(String.Format("Connection being attempted to server {0}", serverAddress.ToString()),
// PS3LogLevels.connection);
public static void connectTo(BlutoSubAddress serverAddress, ITCPConnectionHandler handler) {
Console.WriteLine($"ClientToServerManagedTCPConnector.connectTo server: {serverAddress}");
Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
EndPoint ep = new IPEndPoint(IPAddress.Parse(serverAddress.ip), serverAddress.port);
sock.BeginConnect(ep, new AsyncCallback(myOnConnect), new SocketConnectionArgs(ep, sock, handler, serverAddress.ToString()));
}
private static void myOnConnect(IAsyncResult res)
{
public static async Task connect_to_async(BlutoSubAddress serverAddress, ITCPConnectionHandler handler, TimeSpan wait_before_retrying, int max_n_attempts = 1024) {
bts.Log.Gen.info($"ClientToServerManagedTCPConnector.connectTo server: {serverAddress}");
await TCPSocketUtils.connect_to_server_async(serverAddress.ip, serverAddress.port, handler, wait_before_retrying, max_n_attempts);
}
public static void connect_to(BlutoSubAddress serverAddress, ITCPConnectionHandler handler, TimeSpan wait_before_retrying, int max_n_attempts = 1024) {
bts.Log.Gen.info($"ClientToServerManagedTCPConnector.connectTo server: {serverAddress}");
Task.Run(async () => {
await TCPSocketUtils.connect_to_server_async(serverAddress.ip, serverAddress.port, handler, wait_before_retrying, max_n_attempts);
});
}
private static void myOnConnect(IAsyncResult res) {
Console.WriteLine("ClientToServerManagedTCPConnector.myOnConnect " + res.ToString() + " " + res.AsyncState.ToString());
SocketConnectionArgs args = res.AsyncState as SocketConnectionArgs;
try
{
try {
args.sock.EndConnect(res);
}
catch (SocketException sex)
{
} catch (SocketException sex) {
string errMsg = String.Format("{0}: Connection to {1} failed.", DateTime.Now.ToString(), args.serverURL.ToString());
//BlueEventLog.logEvent(sex.Message + ";" + errMsg, PS3LogLevels.disconnection);
//Console.WriteLine(errMsg);
if (args.handler.isDisposed)
{
if (args.handler.isDisposed) {
string doneMsg = String.Format("{0}: Connection to {1} was disposed. Not Retrying.", DateTime.Now.ToString(), args.serverURL.ToString());
//Console.WriteLine(doneMsg);
// BlueEventLog.logEvent(doneMsg, PS3LogLevels.disconnection);
return;
}
else
{
} else {
string retryMsg = String.Format("{0}: Retrying Connection to {1}.", DateTime.Now.ToString(), args.serverURL.ToString());
//Console.WriteLine(retryMsg);
//BlueEventLog.logEvent(retryMsg, PS3LogLevels.disconnection);
@@ -2,15 +2,13 @@ using System;
using System.Collections.Generic;
using System.Text;
namespace BCG
{
namespace BCG {
public delegate void SendConfirmationDelegate(string messageId, bool confirmed);
/// <summary>
/// This is the very basic connection that sits right
/// on top of the sockets (unmanaged, managed whatever).
/// on top of the sockets (used on both server and client)
/// </summary>
public interface ITCPConnection : IDisposable
{
public interface ITCPConnection : IDisposable {
/// <summary>
/// The delegate is fired signalling if the data send was
/// successful or not
@@ -18,7 +16,7 @@ namespace BCG
/// <param name="data"></param>
/// <param name="confId"></param>
/// <param name="del"></param>
void sendWithConfirmation (byte[] data, ref string confId, SendConfirmationDelegate del);
void sendWithConfirmation(byte[] data, ref string confId, SendConfirmationDelegate del);
/// <summary>
/// sends data to the other side. theres no guaranatee that
/// data is delievered.
@@ -54,6 +52,6 @@ namespace BCG
/// hence this is an indicator of whether the connection is
/// alive or dead
/// </summary>
bool isDisposed { get;}
bool isDisposed { get; }
}
}
@@ -2,13 +2,11 @@ using System;
using System.Collections.Generic;
using System.Text;
namespace BCG
{
namespace BCG {
/// <summary>
/// Type of messages that can be sent over the transport.
/// </summary>
public enum RemoteMessageType
{
public enum RemoteMessageType {
heartbeat, data, connection, disconnection
}
@@ -17,33 +15,33 @@ namespace BCG
/// This can be a transport generated message (heartbeat) or user generated
/// message (data)
/// </summary>
public class RemoteMessage
{
public class RemoteMessage {
private byte[] myMsg;
private RemoteMessageType myMsgType;
private RemoteConnectionInfo myConnInfo;
public RemoteMessage(byte[] message, RemoteMessageType messageType, RemoteConnectionInfo connInfo)
{
public RemoteMessage(byte[] message, RemoteMessageType messageType, RemoteConnectionInfo connInfo) {
myMsg = message;
myMsgType = messageType;
myConnInfo = connInfo;
}
public byte[] message
{
public byte[] message {
get { return myMsg; }
}
public RemoteMessageType messageType
{
public RemoteMessageType messageType {
get { return myMsgType; }
}
public RemoteConnectionInfo remoteConnectionInfo
{
public RemoteConnectionInfo remoteConnectionInfo {
get { return myConnInfo; }
}
override public string ToString() {
Func<byte[], int> len = (byte[] m) => { return m == null ? 0 : m.Length; };
return $"type: {myMsgType} conn: {myConnInfo} msg: {len(myMsg)}";
}
}
}
@@ -5,39 +5,45 @@ using System.Text;
//using BCG.Utilities.General;
//using BCG.Utilities;
namespace BCG
{
public class ServerToClientManagedTCPConnectionAcceptor
{
namespace BCG {
public class ServerToClientManagedTCPConnectionAcceptor {
private static Dictionary<int, SingleServerToClientManagedTCPConnectionAcceptor> myPortToSingleServerAcceptorMap = new Dictionary<int, SingleServerToClientManagedTCPConnectionAcceptor>();
private static object mySyncObject = new object();
public static int activateWithRandomPort(ITCPConnectionHandler handler, TimeSpan clientHBTimeSpan)
{
public static int activateWithRandomPort(ITCPConnectionHandler handler, TimeSpan clientHBTimeSpan) {
SingleServerToClientManagedTCPConnectionAcceptor theAcceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
int portNo = theAcceptor.activateWithRandomPort(handler, clientHBTimeSpan);
lock (mySyncObject)
{
lock (mySyncObject) {
myPortToSingleServerAcceptorMap[portNo] = theAcceptor;
}
return portNo;
return portNo;
}
public static int activate(ITCPConnectionHandler handler, int port, TimeSpan clientHBTimeSpan)
{
lock (mySyncObject)
{
if (myPortToSingleServerAcceptorMap.ContainsKey(port))
{
public static int activate(ITCPConnectionHandler handler, int port, TimeSpan clientHBTimeSpan) {
lock (mySyncObject) {
if (myPortToSingleServerAcceptorMap.ContainsKey(port)) {
string msg = string.Format("Error: Application is already accepting clients on port {0}", port);
// BlueEventLog.logEvent(msg, BlueEventLog2Level.Error);
return port;
} else {
SingleServerToClientManagedTCPConnectionAcceptor theAcceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
int assignedport = theAcceptor.activate(handler, port, clientHBTimeSpan);
myPortToSingleServerAcceptorMap[assignedport] = theAcceptor;
return assignedport;
}
else
{
} //end lock
} //end activate code
public static int accept_connections(ITCPConnectionHandler handler, int port, TimeSpan clientHBTimeSpan) {
lock (mySyncObject) {
if (myPortToSingleServerAcceptorMap.ContainsKey(port)) {
string msg = string.Format("Error: Application is already accepting clients on port {0}", port);
// BlueEventLog.logEvent(msg, BlueEventLog2Level.Error);
return port;
} else {
SingleServerToClientManagedTCPConnectionAcceptor theAcceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
int assignedport = theAcceptor.activate(handler, port, clientHBTimeSpan);
myPortToSingleServerAcceptorMap[assignedport] = theAcceptor;
@@ -47,5 +53,7 @@ namespace BCG
} //end activate code
}
}
@@ -4,13 +4,12 @@ using System.Text;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Threading.Tasks;
//using BCG.Utilities;
namespace BCG
{
public class SingleServerToClientManagedTCPConnectionAcceptor
{
namespace BCG {
public class SingleServerToClientManagedTCPConnectionAcceptor {
private TimeSpan myHBTimeSpan,
myWaitTimeBeforeRetrying = new TimeSpan(0, 0, 0, 0, 250);
private ITCPConnectionHandler myHandler;
@@ -18,58 +17,50 @@ namespace BCG
private int myPort;
public int activateWithRandomPort(ITCPConnectionHandler handler, TimeSpan clientHBTimeSpan)
{
public int activateWithRandomPort(ITCPConnectionHandler handler, TimeSpan clientHBTimeSpan) {
myHBTimeSpan = clientHBTimeSpan;
myHandler = handler;
myAcceptSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int port = 0;
bool madeItThrough = false;
// BlueEventLog.logEvent("Looking for open port to run the server on.", PS3LogLevels.connection);
// BlueEventLog.logEvent("Looking for open port to run the server on.", PS3LogLevels.connection);
Random randomizer = new Random();
PubSubPortRange theRange = PubSub3Config.instance.PS3_PortRange;
//if the range of ports is 1000, then trying 5,000 times means
//your odds of missing an open port are less than 1%
int maxAttempts = (theRange.maxPort - theRange.minPort) * 5;
int maxAttempts = (theRange.maxPort - theRange.minPort) * 5;
int totalAttempts = 0;
while (!madeItThrough)
{
port = randomizer.Next();
while (!madeItThrough) {
port = randomizer.Next();
port = theRange.minPort + (port % (theRange.maxPort - theRange.minPort));
try
{
try {
myAcceptSock.Bind(new IPEndPoint(IPAddress.Any, port));
madeItThrough = true;
}
catch (Exception)
{
} catch (Exception) {
totalAttempts++;
if (totalAttempts < maxAttempts){
if (totalAttempts < maxAttempts) {
//BlueEventLog.logEvent("Couldn't bind to port " + port.ToString() + "; retrying...", PS3LogLevels.connection);
}
else
{
} else {
// BlueEventLog2.instance().abort("Couldn't find an open port to advertise the server on. Consider modifying PS3_PortRange. Talk to Mark for details.");
}
}
}
myPort = port;
myAcceptSock.Listen(250);
myAcceptSock.BeginAccept(new AsyncCallback(myOnAccept), new object[] { });
myAcceptSock.BeginAccept(new AsyncCallback(myOnAccept), new object[] { });
return myPort;
}
public int activate (ITCPConnectionHandler handler, int port, TimeSpan clientHBTimeSpan)
{
public int activate(ITCPConnectionHandler handler, int port, TimeSpan clientHBTimeSpan) {
myHBTimeSpan = clientHBTimeSpan;
myHandler = handler;
myAcceptSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint endpoint = new IPEndPoint (IPAddress.Any, port);
IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, port);
myAcceptSock.Bind(endpoint);
myAcceptSock.Listen(250);
myAcceptSock.BeginAccept(new AsyncCallback(myOnAccept), new object[] { });
@@ -77,15 +68,18 @@ namespace BCG
return myPort; // not sure why we need this class variable myPort, but I am just keeping it up with the existing code
}
private void myOnAccept(IAsyncResult res)
{
public int accept_on_port(ITCPConnectionHandler handler, string ip, int port, TimeSpan clientHBTimeSpan) {
Task.Run(async () => {
await TCPSocketUtils.accept_connections_async(ip, port, handler, TimeSpan.FromSeconds(1));
});
return port;
}
private void myOnAccept(IAsyncResult res) {
Socket newSock;
try
{
try {
newSock = myAcceptSock.EndAccept(res);
}
catch (Exception ex)
{
} catch (Exception ex) {
// BlueEventLog.logEvent(ex);
Thread.Sleep(myWaitTimeBeforeRetrying);
myAcceptSock.BeginAccept(new AsyncCallback(myOnAccept), new object[] { });
@@ -98,10 +92,10 @@ namespace BCG
ITCPConnection newConn = new AsyncTCPConnection(newSock, myHBTimeSpan);
myHandler.onConnection(newConn);
myAcceptSock.BeginAccept(new AsyncCallback(myOnAccept), new object[] { });
string ip;int port;
newConn.getPeerAddress (out ip, out port);
string ip; int port;
newConn.getPeerAddress(out ip, out port);
string connMsg = String.Format("Connection to port {2} made from {0}:{1}", ip, port, myPort);
// BlueEventLog.logEvent(connMsg, PS3LogLevels.connection);
// BlueEventLog.logEvent(connMsg, PS3LogLevels.connection);
//Console.WriteLine(connMsg);
}
}
@@ -0,0 +1,113 @@
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
{
// utility functions for TCP socket async communications. Does the following
// client to server connect
// server to client connect accepting
// send data
// receive data
public static class TCPSocketUtils
{
#region socket opening and connecting
// keeps accepting connections forever
public static async Task accept_connections_async(string ip, int port, ITCPConnectionHandler handler,
TimeSpan wait_after_error)
{
IPAddress ipAddress = String.IsNullOrEmpty(ip) ? IPAddress.Parse(ip) : IPAddress.Any;
var ip_end_point = new IPEndPoint(ipAddress, port);
Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listener.Bind(ip_end_point);
listener.Listen(10);
Socket client_socket = null;
while (true)
{
try
{
// keeps on accepting connections
client_socket = await listener.AcceptAsync();
AsyncTCPConnection2 new_conn = new(client_socket, AsyncTCPConnection2.ConnectionSide.Server);
handler.onConnection(new_conn);
}
catch (Exception ex)
{
bts.Log.Gen.error($"TCPConnection.accept ex: {ex} trying again");
Task.Delay(wait_after_error);
}
}
}
// connects to the server and ona successful connection, calls con__handler.on_connection_async with an ITCPConnection.
// In case of failures to connect it waits for a given amount of time before retrying
public static async Task<Socket> connect_to_server_async(string ip, int server_port, ITCPConnectionHandler conn_handler,
TimeSpan wait_after_failed_attempt, int n_max_attempts = 1024)
{
Socket client_socket = null;
for (int i = 0; i < n_max_attempts; i++)
{
try
{
string log_conn = $"{ip}:{server_port}";
bts.Log.Gen.info($"AsyncTCPConnection2.connect_to_server conn: {log_conn} attempt no: {i}");
IPAddress server_ip_address = IPAddress.Parse(ip);
client_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client_socket.ConnectAsync(server_ip_address, server_port);
bts.Log.Gen.info($"AsyncTCPConnection2.connect_to_server conn: {log_conn} successfully connected after {i} attempts");
ITCPConnection new_conn = new AsyncTCPConnection2(client_socket, AsyncTCPConnection2.ConnectionSide.Client);
conn_handler.onConnection(new_conn);
break;
}
catch (Exception ex)
{
bts.Log.Gen.error($"AsyncTCPConnection2.connect_to_server threw ex: {ex}, will reattempt now");
Task.Delay(wait_after_failed_attempt);
}
}
return client_socket;
}
#endregion
#region data sending/receiving
// prefixes the size of the data and sends it as 2 sends, for size and data
// (can be done as one send perhaps)
public static async Task send_bytes_async(NetworkStream nw_stream, byte[] data_buff)
{
var data_sz = data_buff.Length;
byte[] sz_buff = new byte[4];
// aend the size first
BinaryWriter bw = new BinaryWriter(new MemoryStream(sz_buff));
bw.Write(data_sz);
await nw_stream.WriteAsync(sz_buff, 0, 4);
await nw_stream.WriteAsync(data_buff, 0, data_buff.Length);
}
// reads the bytes on a connected socket, by doing the opposite of the above,
// reads the size first and then the data
public static async Task<byte[]> read_bytes_async(NetworkStream nw_stream)
{
byte[] sz_buffer = new byte[4];
//Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
int bytesRead = await nw_stream.ReadAsync(sz_buffer, 0, sz_buffer.Length);
BinaryReader br = new BinaryReader(new MemoryStream(sz_buffer));
int msg_sz = br.ReadInt32();
byte[] data_buffer = new byte[msg_sz];
bytesRead = await nw_stream.ReadAsync(data_buffer, 0, data_buffer.Length);
//Console.WriteLine($"read_bytes sz: {data_buffer.Length}");
return data_buffer;
}
#endregion
}
}
@@ -0,0 +1,103 @@
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 System.Data;
namespace BCG {
public class SimpleTCPServerAsync : ITCPConnectionHandler, ITCPMessageHandler {
private AsyncTCPConnection2 _conn = null;
int _n_msgs_received = 0;
SingleServerToClientManagedTCPConnectionAcceptor _acceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
public static async Task start() {
Console.WriteLine("SimpleTCPServer.start accepting socket connections");
SimpleTCPServerAsync s = new SimpleTCPServerAsync();
//await AsyncTCPConnection2.accept_connections("127.0.0.1", 12345, s, TimeSpan.FromMilliseconds(100));
s.accept();
}
// public static async Task init()
// {
// }
public void accept() {
_acceptor.accept_on_port(this, "127.0.0.1", 12345, TimeSpan.Zero);
}
public void onConnection(ITCPConnection connection) {
Console.WriteLine("SimpleTCPServerAsync.onConnection new client connected");
_conn = connection as AsyncTCPConnection2;
connection.register(this);
}
public void onData(RemoteMessage msg) {
_n_msgs_received++;
Console.WriteLine($"SimpleTCPServerAsync.onData msgs_received: {_n_msgs_received} msg: {msg} , echoing it back");
if (msg.messageType == RemoteMessageType.data && _conn != null) {
//_conn.send(msg.message);
Task.Run(async () => {
Console.WriteLine($"SimpleTCPServerAsync.onData sending msg: {msg} to client");
await _conn.send_async(msg.message);
});
}
}
public bool isDisposed { get { return false; } }
public void Dispose() { }
}
public class SimpleTCPServer : ITCPConnectionHandler, ITCPMessageHandler {
private AsyncTCPConnection2 _conn = null;
private int _n_msgs_received = 0;
SingleServerToClientManagedTCPConnectionAcceptor _acceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
public static async Task start() {
Console.WriteLine("SimpleTCPServer.start accepting socket connections");
SimpleTCPServer s = new SimpleTCPServer();
s.accept();
//await AsyncTCPConnection2.accept_connections("127.0.0.1", 12345, s, TimeSpan.FromMilliseconds(100));
}
public void accept() {
_acceptor.accept_on_port(this, "127.0.0.1", 12345, TimeSpan.Zero);
}
public void onConnection(ITCPConnection connection) {
Console.WriteLine("SimpleTCPServerAsync.onConnection new client connected");
_conn = connection as AsyncTCPConnection2;
connection.register(this);
}
public async void onData(RemoteMessage msg) {
_n_msgs_received++;
Console.WriteLine($"SimpleTCPServerAsync.onData msg: {msg} , msgs received: {_n_msgs_received} echoing it back");
if (msg.messageType == RemoteMessageType.data && _conn != null) {
Task.Run(async () => {
//Console.WriteLine($"SimpleTCPServerAsync.onData sending msg: {msg} to client");
await _conn.send_async(msg.message);
});
}
}
public bool isDisposed { get { return false; } }
public void Dispose() { }
}
}
+9 -12
View File
@@ -1,22 +1,22 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Linq;
//using BCG.Utilities;
//using BCG.Utilities.General;
namespace BCG
{
class PubSub2Main
{
namespace BCG {
class PubSub2Main {
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
public static void Main(string[] args)
{
public static async Task Main(string[] args) {
SimpleTCPServerAsync.start();
Task.Delay(1000000000).Wait();
if (args.Length > 0 && args[0] == "daemon")
args = args.Skip(1).ToArray();
@@ -26,14 +26,11 @@ namespace BCG
long currentMemory = 0;
int defaultWaitTime = 100;
bool gced = false;
new Thread(() =>
{
while (true)
{
new Thread(() => {
while (true) {
gced = false;
currentMemory = GC.GetTotalMemory(false);
if (config.PS3_GCActivationThreshold > 0 && currentMemory > config.PS3_GCActivationThreshold)
{
if (config.PS3_GCActivationThreshold > 0 && currentMemory > config.PS3_GCActivationThreshold) {
string gcMsg = String.Format("GCing memory, mem before GC = {0}", currentMemory);
// BlueEventLog.logEvent(gcMsg, PS3LogLevels.info);
Console.WriteLine(gcMsg);