Merging, and adding test project
This commit is contained in:
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)}";
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
+25
-17
@@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
+29
-35
@@ -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() { }
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user