/// <summary> /// Starts the agent. /// </summary> /// <param name="pServerAdress">The server adress.</param> /// <param name="pServerPort">The server port.</param> /// <param name="pClientId">The client identifier.</param> public void Start(string pServerAdress, int pServerPort, string pClientId) { try { this.mServerAdress = pServerAdress; this.mServerPort = pServerPort; this.Id = pClientId; this.Socket = AweSock.TcpConnect(pServerAdress, pServerPort); this.mHandler = new AgentClientHandler(this, this.mReconnectIndex); this.mThread = new Thread(this.mHandler.Update) { Name = "Client " + this.mReconnectIndex }; this.mThread.Start(); this.mReconnectIndex++; this.mReconnectionTimer.Enabled = false; this.Send(new DeclareClient(pClientId)); } catch { Console.WriteLine("[" + this.Id + "] Try to reconnect"); this.mReconnectionTimer.Enabled = true; } }
public void ReceiveNextMessage(bool skipConnectingEvents, ISocket connection, ISynchroMessage targetMessage) { try { Buffer.Resize(inBuf, sizeof(int)); AweSock.ReceiveMessage(connection, inBuf); int messageLength = Buffer.Get <int>(inBuf); Buffer.Resize(inBuf, messageLength); int received = 0; do { received += AweSock.ReceiveMessage(connection, inBuf, received); if (received == 0) { throw new SocketException(); } } while (received < messageLength); targetMessage.Deserialize(inBuf); } catch (SocketException) { connections.Remove(connection); } }
public override void Connect() { int tryCounter = 0; nextTry: try { connections.Add(AweSock.TcpConnect(NodeInformation.master.ip, NodeInformation.master.port + 1)); } catch (Exception) { Debug.Log("Could not connect to server. Trying again."); if (++tryCounter >= 10) { #if UNITY_EDITOR UnityEditor.EditorApplication.isPlaying = false; #else Application.Quit(); #endif return; } Thread.Sleep(500); goto nextTry; } InitializeSelf(); }
private void button1_Click(object sender, System.EventArgs e) { if (_serverSocket != null) { _serverSocket.Close(); } _serverSocket = AweSock.TcpConnect(ipTextBox.Text, int.Parse(portTextBox.Text)); }
public ISocket Apply(ISocket socket) { //TODO: Need to check if socket is UDP as Multicast only works with UDP... AweSock.SetSockOpt(socket, new Dictionary <SocketOptionName, object> { { SocketOptionName.AddMembership, new MulticastOption(_multicastIpAddress, IPAddress.Parse("127.0.0.1")) } }); return(socket); }
public override void Connect() { listenSocket = AweSock.TcpListen(NodeInformation.own.port + 1); while (connections.Count < targetClientNumber) { connections.Add(AweSock.TcpAccept(listenSocket)); InitializeClient(connections[connections.Count - 1]); } }
/// <summary> /// Starts the agent. /// </summary> public void Start(int pPort) { this.ListenSocket = AweSock.TcpListen(pPort); AweSock.TcpAccept(this.ListenSocket, SocketCommunicationTypes.NonBlocking, this.NewClient); this.mHandler = new AgentServerHandler(this); this.mThread = new Thread(this.mHandler.Update); this.mThread.Start(); }
private void ServerThread(Action <bool> callback) { var sendBuffer = Buffer.New(); var recvBuffer = Buffer.New(); var listenSocket = AweSock.TcpListen(14804); var client = AweSock.TcpAccept(listenSocket); SendTestMessage(client, sendBuffer); callback(ReceiveResponseFromClient(client, recvBuffer)); }
public void ClientThread(Action <bool> callback) { Buffer sendBuffer = Buffer.New(); Buffer recvBuffer = Buffer.New(); ISocket server = AweSock.TcpConnect("127.0.0.1", 14804); ReceiveMessageFromServer(server, recvBuffer); SendTestMessage(server, sendBuffer); callback(true); }
void Listen() { syncServer = AweSock.TcpListen(port); Thread.Sleep(3000); Log.Notice("Master Server is listening on {0}:{1}", ip, port); while (true) { var client = AweSock.TcpAccept(syncServer); var receiver = new IPCReceiver(client, this); } }
bool SendIPC(AwesomeSockets.Buffer packet) { try { AweSock.SendMessage(socket, packet); return(true); } catch (Exception) { return(false); } }
bool ReadIPC(AwesomeSockets.Buffer packet) { try { AweSock.ReceiveMessage(syncClient, packet); return(true); } catch (Exception) { return(false); } }
private void StartServer(int serverPort) { if (_listenSocket != null) { _listenSocket.Close(); _listenSocket = null; } _listenSocket = AweSock.TcpListen(serverPort); //Non-blocking mode AweSock.TcpAccept(_listenSocket, SocketCommunicationTypes.NonBlocking, AcceptClient); _logger.Info($"Listening on port: {serverPort}"); }
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); }
/// <summary> /// This method is called each time a new client is connected. /// </summary> /// <param name="pClientSocket">The client socket.</param> /// <param name="pError">The error during connection.</param> /// <returns></returns> private Socket NewClient(ISocket pClientSocket, Exception pError) { if (pClientSocket?.GetSocket() != null) { AweSock.TcpAccept(this.ListenSocket, SocketCommunicationTypes.NonBlocking, this.NewClient); ClientView lClientView = new ClientView() { Socket = pClientSocket }; this.Clients.TryAdd(lClientView, lClientView); this.ClientConnected?.Invoke(this, lClientView, null); return(pClientSocket.GetSocket()); } return(null); }
void ReceiveThread() { while (true) { AwesomeSockets.Buffer.ClearBuffer(recvBuffer); try { AweSock.ReceiveMessage(socket, recvBuffer); PipeServer.ProcessPacket(this, recvBuffer); } catch (Exception) { rThread.Abort(); } } }
private void ListenForMessages(ISocket socket) { var callbackFired = new ManualResetEventSlim(false); var receiveBuffer = ASBuffer.New(); while (!CancelToken.IsCancellationRequested) { ASBuffer.ClearBuffer(receiveBuffer); Tuple <int, EndPoint> result = null; try { AweSock.ReceiveMessage(socket, receiveBuffer, AwesomeSockets.Domain.SocketCommunicationTypes.NonBlocking, (b, endPoint) => { result = new Tuple <int, EndPoint>(b, endPoint); callbackFired.Set(); }); } catch (ArgumentOutOfRangeException) { // Swallow the exception caused by AweSock's construction of an invalid endpoint } try { callbackFired.Wait(CancelToken); } catch (OperationCanceledException) { } if (!CancelToken.IsCancellationRequested) { callbackFired.Reset(); ASBuffer.FinalizeBuffer(receiveBuffer); if (result.Item1 == 0) { return; } var length = ASBuffer.Get <short>(receiveBuffer); var bytes = new byte[length]; ASBuffer.BlockCopy(ASBuffer.GetBuffer(receiveBuffer), sizeof(short), bytes, 0, length); MessageReceived?.Invoke(this, new MessageReceivedEventArgs() { Message = bytes }); } } }
void Listen() { Thread.Sleep(1000); Log.Notice("Starting sync connection with Master Server..."); Thread.Sleep(1000); hbTimer = new System.Timers.Timer(1000 * 36); // heartbeat every 30 seconds hbTimer.AutoReset = true; hbTimer.Elapsed += (sender, e) => { HeartBeat(); }; while (true) { if (syncClient == null && !syncRunning) { try { syncClient = AweSock.TcpConnect(ip, port); syncRunning = true; hbTimer.Start(); Log.Notice("Established sync connection with Master Server!"); SyncSuccess(this, new EventArgs()); } catch (Exception) { syncRunning = false; Log.Error("Failed to establish sync connection to Master Server!", "[ObjectBuddy::SyncReceiver::Listen()]"); SyncFailed(this, new EventArgs()); } } if (syncRunning) { if (!syncClient.GetSocket().Connected) { hbTimer.Stop(); syncClient = null; syncRunning = false; Log.Error("Lost sync connection to Master Server!", "[ObjectBuddy::SyncReceiver::Listen()]"); } } Thread.Sleep(1); } }
private static void ReceiveMessageFromServer(ISocket server, Buffer recvBuffer) { var clientExitFlag = false; do { var(item1, _) = AweSock.ReceiveMessage(server, recvBuffer); if (item1 > 0) { clientExitFlag = true; } else if (item1 == 0) { return; } Thread.Sleep(1000); } while (!clientExitFlag); }
public void ListenForMessages(ISocket socket) { var receiveBuffer = ASBuffer.New(); while (!CancelToken.IsCancellationRequested) { ASBuffer.ClearBuffer(receiveBuffer); Tuple <int, EndPoint> result = null; try { result = AweSock.ReceiveMessage(socket, receiveBuffer); } catch (SocketException) { ClientSockets.TryRemove(socket, out byte _); break; // TODO: Determine which exceptions are intermittent and handle recovering before just bailing out } if (result.Item1 == 0) { return; } var sendBuffer = ASBuffer.Duplicate(receiveBuffer); ASBuffer.FinalizeBuffer(sendBuffer); foreach (var client in ClientSockets.Keys) { #if RELEASE if (client != socket) #endif { // TODO: Does this work for displaying myself? try { client.SendMessage(sendBuffer); } catch (SocketException) { // Swallow the exception trying to send, if it's not intermittent (connection closed etc) the receive message will throw and we handle it there (in another Task) } } } } }
public void ListenForConnections() { var taskFactory = new TaskFactory(); ListenSocket = AweSock.TcpListen(ListenPort); while (!CancelToken.IsCancellationRequested) { try { var clientSocket = AweSock.TcpAccept(ListenSocket); ClientSockets.TryAdd(clientSocket, 0); var listenTask = new Task(() => ListenForMessages(clientSocket), TaskCreationOptions.LongRunning); listenTask.ContinueWith(t => { lock (ListenTasks) { ListenTasks.Remove(t); } }).ConfigureAwait(false); lock (ListenTasks) { ListenTasks.Add(listenTask); } listenTask.Start(); } catch (SocketException) { if (!CancelToken.IsCancellationRequested) { try { // Try and re-connect. Thread.Sleep(1000); ListenSocket = AweSock.TcpListen(ListenPort); } catch (SocketException) { } } } } }
private async Task ListenInternalAsync() { try { if (await IPAddressSetting.IsValidAsync()) { Socket = AweSock.TcpConnect(IPAddressSetting.Value.Split(':')[0], int.Parse(IPAddressSetting.Value.Split(':')[1])); ListenForMessages(Socket); } } catch (SocketException) { await Task.Delay(1000); if (!CancelToken.IsCancellationRequested) { // TODO: Handle socket exception (try and re-connect after a while?) } } }
private bool ReceiveMessageFromServer(ISocket server, Buffer recvBuffer) { bool CLIENT_EXIT_FLAG = false; do { var bytesReceived = AweSock.ReceiveMessage(server, recvBuffer); if (bytesReceived.Item1 > 0) { CLIENT_EXIT_FLAG = true; } else if (bytesReceived.Item1 == 0) { return(false); } Thread.Sleep(1000); } while (!CLIENT_EXIT_FLAG); return(true); }
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); } }
void ReceiveThread() { while (true) { AwesomeSockets.Buffer.ClearBuffer(recvBuffer); try { AweSock.ReceiveMessage(socket, recvBuffer); var reader = new IPCReader(recvBuffer); var packet = reader.Opcode; ipc.HandlePacket(this, reader, packet); } catch (Exception) { if (serverId > 0 && channelId > 0) { ipc.RemoveChannel(serverId, channelId); // let's remove channel from list } rThread.Abort(); } } }
private bool ReceiveResponseFromClient(ISocket client, Buffer recvBuffer) { bool SERVER_EXIT_FLAG = false; do { var bytesReceived = AweSock.ReceiveMessage(client, recvBuffer); if (bytesReceived.Item1 > 0) { if (!ValidateResponse(recvBuffer)) { return(false); } SERVER_EXIT_FLAG = true; } else if (bytesReceived.Item1 == 0) { return(false); } //Thread.Sleep(1000); } while (!SERVER_EXIT_FLAG); return(true); }
void Listen() { Thread.Sleep(1000); Log.Notice("Starting Sync with the Master Server"); Thread.Sleep(1000); while (true) { if (syncClient == null && !syncRunning) { try { syncClient = AweSock.TcpConnect(ip, port); syncRunning = true; Log.Notice("Established Sync connection to the Master Server"); SyncSuccess(this, new EventArgs()); } catch (Exception) { syncRunning = false; Log.Error("Sync with the Master Server failed!"); } } if (syncRunning) { if (!syncClient.GetSocket().Connected) { syncClient = null; syncRunning = false; } } Thread.Sleep(1); } }
private bool ReceiveResponseFromClient(ISocket client, Buffer recvBuffer) { var serverExitFlag = false; do { var(item1, _) = AweSock.ReceiveMessage(client, recvBuffer); if (item1 > 0) { if (!ValidateResponse(recvBuffer)) { return(false); } serverExitFlag = true; } else if (item1 == 0) { return(false); } //Thread.Sleep(1000); } while (!serverExitFlag); return(true); }
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); } } }
/// <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"); }