bool SendIPC(AwesomeSockets.Buffer packet)
{
try
{
AweSock.SendMessage(syncClient, packet);
return(true);
}
catch (Exception)
{
return(false);
}
}
private void SendTestMessage(ISocket other, Buffer sendBuffer)
{
Buffer.ClearBuffer(sendBuffer);
Buffer.Add(sendBuffer, 10);
Buffer.Add(sendBuffer, 20.0F);
Buffer.Add(sendBuffer, 40.0);
Buffer.Add(sendBuffer, 'A');
Buffer.Add(sendBuffer, "The quick brown fox jumped over the lazy dog");
Buffer.Add(sendBuffer, (byte)255);
Buffer.FinalizeBuffer(sendBuffer);
var bytesSent = AweSock.SendMessage(other, sendBuffer);
Console.WriteLine("Sent payload. {0} bytes written.", bytesSent);
}
public void SendMessage(ISynchroMessage message, ISocket connection)
{
Buffer.Resize(outBuf, message.GetLength() + sizeof(int));
Buffer.Add(outBuf, message.GetLength());
message.Serialize(outBuf);
Buffer.FinalizeBuffer(outBuf);
try
{
int bytesSent = AweSock.SendMessage(connection, outBuf);
if (bytesSent == 0)
{
throw new NetworkInformationException();
}
}
catch (SocketException)
{
connections.Remove(connection);
}
}
/// <summary>
/// This method is called by the thread.
/// </summary>
public void Update()
{
while (this.mIsRunning)
{
// Check if the server must send data.
if (this.mServer.PendingCommands.Any())
{
// Clear all buffers.
foreach (var lNetBuffer in this.mNetBuffers)
{
AweBuffer.ClearBuffer(lNetBuffer.Value);
}
// Encode all commands.
foreach (var lCommand in this.mServer.PendingCommands)
{
if (string.IsNullOrWhiteSpace(lCommand.Value.ClientId))
{
foreach (var lClientView in this.mServer.Clients)
{
if (string.IsNullOrWhiteSpace(lClientView.Value.Id) == false)
{
if (this.mNetBuffers.ContainsKey(lClientView.Value.Id) == false)
{
this.mNetBuffers.Add(lClientView.Value.Id, AweBuffer.New());
}
lCommand.Value.HasBeenEncoded = true;
AweBuffer.Add(this.mNetBuffers[lClientView.Value.Id], lCommand.Value.Encode() + ";");
}
}
}
else
{
if (this.mNetBuffers.ContainsKey(lCommand.Value.ClientId) == false)
{
this.mNetBuffers.Add(lCommand.Value.ClientId, AweBuffer.New());
}
lCommand.Value.HasBeenEncoded = true;
AweBuffer.Add(this.mNetBuffers[lCommand.Value.ClientId], lCommand.Value.Encode() + ";");
}
}
foreach (var lNetBuffer in this.mNetBuffers)
{
AweBuffer.FinalizeBuffer(lNetBuffer.Value);
}
// Send data to each client.
bool lErrorOccured = false;
foreach (var lNetBuffer in this.mNetBuffers)
{
var lClient = this.mServer.Clients.FirstOrDefault(pClient => pClient.Value.Id == lNetBuffer.Key);
if (lClient.Value != null && lClient.Value.Status != Status.Lost)
{
try
{
AweSock.SendMessage(lClient.Value.Socket, lNetBuffer.Value);
}
catch
{
lErrorOccured = true;
Console.WriteLine("Lost client");
this.mServer.LostClient(lClient.Value);
}
}
}
// Notifies all commands.
if (lErrorOccured == false)
{
foreach (var lCommand in this.mServer.PendingCommands)
{
if (lCommand.Value.HasBeenEncoded)
{
this.mServer.NotifyCommandSent(lCommand.Value);
}
}
}
}
// Try to receive some data.
foreach (var lClientView in this.mServer.Clients)
{
try
{
StringBuilder lInBuffer = new StringBuilder();
if (lClientView.Value.Socket != null && lClientView.Value.Socket.GetBytesAvailable() != 0)
{
AweBuffer.ClearBuffer(this.mInBuffer);
Tuple <int, EndPoint> lReceived = AweSock.ReceiveMessage(lClientView.Value.Socket, this.mInBuffer);
if (lReceived.Item1 != 0)
{
lInBuffer.Append(AweBuffer.Get <string>(this.mInBuffer));
if (lInBuffer.Length != 0)
{
this.mServer.Decode(lInBuffer.ToString(), lClientView.Value);
}
}
}
}
catch
{
Console.WriteLine("Lost client");
this.mServer.LostClient(lClientView.Value);
}
}
//Console.WriteLine("[SERVER] Sleep");
Thread.Sleep(1000);
}
//Console.WriteLine("[SERVER] LeaveThread");
}
public async Task StartClient(Trainer trainer)
{
//Request server IP and port number
Console.WriteLine("Please enter the server IP in the format 192.168.0.1 and press return:");
string ip = Console.ReadLine();
Console.WriteLine("Please enter the server port and press return:");
string port = Console.ReadLine();
ISocket server = AweSock.TcpConnect(ip, int.Parse(port));
var inBuf = AwesomeSockets.Buffers.Buffer.New(99999);
var outBuf = AwesomeSockets.Buffers.Buffer.New(99999);
this.SetupClientTrainer(trainer);
while (true)
{
try
{
//get data
var outputData = this.GetOutputData(trainer);
//write data to buffer
AwesomeSockets.Buffers.Buffer.ClearBuffer(outBuf);
AwesomeSockets.Buffers.Buffer.Add(outBuf, Utils.ObjectToByteArray(outputData));
AwesomeSockets.Buffers.Buffer.FinalizeBuffer(outBuf);
//send data
int bytesSent = AweSock.SendMessage(server, outBuf);
Console.WriteLine("sent data");
//get response
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
Tuple <int, EndPoint> received = AweSock.ReceiveMessage(server, inBuf);
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
trainer.timeSinceUpdate = ts.Milliseconds;
AwesomeSockets.Buffers.Buffer.FinalizeBuffer(inBuf);
//parse response
var res = Utils.Deserialize <Dictionary <string, byte[]> >(AwesomeSockets.Buffers.Buffer.GetBuffer(inBuf));
AwesomeSockets.Buffers.Buffer.ClearBuffer(inBuf);
//act on response
//Console.WriteLine(string.Join(", ", res["pos_ally"]));
this.HandleInputData(res, trainer);
//refresh rate
Thread.Sleep(50);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
AwesomeSockets.Buffers.Buffer.ClearBuffer(outBuf);
AwesomeSockets.Buffers.Buffer.ClearBuffer(inBuf);
trainer.Initialize();
Thread.Sleep(50);
}
}
}
public void StartServer(Trainer trainer)
{
Console.WriteLine("Please enter the server port and press return:");
string port = Console.ReadLine();
ISocket listenSocket = AweSock.TcpListen(int.Parse(port));
Console.WriteLine("Server started");
ISocket client = AweSock.TcpAccept(listenSocket);
var inBuf = AwesomeSockets.Buffers.Buffer.New(99999);
var outBuf = AwesomeSockets.Buffers.Buffer.New(99999);
while (true)
{
try
{
//get message
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
Tuple <int, EndPoint> received = AweSock.ReceiveMessage(client, inBuf);
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
trainer.timeSinceUpdate = ts.Milliseconds;
AwesomeSockets.Buffers.Buffer.FinalizeBuffer(inBuf);
//parse message
var res = Utils.Deserialize <Dictionary <string, byte[]> >(AwesomeSockets.Buffers.Buffer.GetBuffer(inBuf));
AwesomeSockets.Buffers.Buffer.ClearBuffer(inBuf);
//act on message
this.HandleInputData(res, trainer);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
AwesomeSockets.Buffers.Buffer.ClearBuffer(outBuf);
AwesomeSockets.Buffers.Buffer.ClearBuffer(inBuf);
trainer.Initialize();
}
try {
//get response data
var outputData = this.GetOutputData(trainer);
//write to buffer
AwesomeSockets.Buffers.Buffer.ClearBuffer(outBuf);
AwesomeSockets.Buffers.Buffer.Add(outBuf, Utils.ObjectToByteArray(outputData));
AwesomeSockets.Buffers.Buffer.FinalizeBuffer(outBuf);
//respond
int bytesSent = AweSock.SendMessage(client, outBuf);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
AwesomeSockets.Buffers.Buffer.ClearBuffer(outBuf);
AwesomeSockets.Buffers.Buffer.ClearBuffer(inBuf);
trainer.Initialize();
}
}
Console.ReadLine();
}
/// <summary>
/// This method is called by the thread.
/// </summary>
public void Update()
{
while (this.mIsRunning)
{
if (this.mClient.Socket != null)
{
// Clear output buffers.
AweBuffer.ClearBuffer(this.mOutBuffer);
AweBuffer.ClearBuffer(this.mInBuffer);
// Encode all commands.
StringBuilder lBuffer = new StringBuilder();
foreach (var lCommand in this.mClient.PendingCommands)
{
lCommand.ClientId = this.mClient.Id;
AweBuffer.Add(this.mOutBuffer, lCommand.Encode());
lBuffer.AppendLine(";"); // End of command.
lCommand.HasBeenEncoded = true;
}
AweBuffer.FinalizeBuffer(this.mOutBuffer);
// Send data to the server.
try
{
AweSock.SendMessage(this.mClient.Socket, this.mOutBuffer);
}
catch (Exception lEx)
{
this.mClient.LostServer();
break;
}
// Notifies all commands.
foreach (var lCommand in this.mClient.PendingCommands)
{
if (lCommand.HasBeenEncoded)
{
this.mClient.NotifyCommandSent(lCommand);
}
}
this.mClient.PendingCommands.Clear();
// Try to receive some data.
StringBuilder lInBuffer = new StringBuilder();
try
{
if (this.mClient.Socket.GetBytesAvailable() != 0)
{
Tuple <int, EndPoint> lReceived = AweSock.ReceiveMessage(this.mClient.Socket, this.mInBuffer);
if (lReceived.Item1 == 0)
{
lInBuffer.Append(AweBuffer.Get <string>(this.mInBuffer));
}
}
}
catch (Exception lEx)
{
this.mClient.LostServer();
break;
}
if (lInBuffer.Length != 0)
{
this.mClient.Decode(lInBuffer.ToString());
}
}
Console.WriteLine("[" + this.mClient.Id + "] Sleep");
Thread.Sleep(1000);
}
Console.WriteLine("[" + this.mClient.Id + "] LeaveThread");
}
