/// <summary> /// Disconnects from the TcpState that accepts client connections. /// This server instance may not be used after calling this method. /// Calls the method that writes data to the Game's MySQL database. /// </summary> public void Disconnect() { _tcpState?.StopAcceptingClientConnections(); StopGameLoop(); writeToDatabase(); ServerDisconnected?.Invoke(); }
private void MeshClientServerDisconnected(object sender, EventArgs args) { Logger?.Invoke("[MeshClient] Server " + PeerNode.IpPort + " disconnected"); Task unawaited = Task.Run(() => ReconnectToServer()); ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode)); }
private void AfterConnect(Task task) { if (task.IsCompleted) { if (_ClientWs.State == WebSocketState.Open) { Task.Run(() => { Task.Run(() => DataReceiver(), _Token); ServerConnected?.Invoke(this, EventArgs.Empty); }, _Token); } else { if (DisconnectEventConnecting) { ServerDisconnected?.Invoke(this, EventArgs.Empty); InternalServerDisconnected?.Invoke(this, EventArgs.Empty); } } } else { if (DisconnectEventConnecting) { ServerDisconnected?.Invoke(this, EventArgs.Empty); InternalServerDisconnected?.Invoke(this, EventArgs.Empty); } } }
private void AfterConnect(Task task) { if (task.IsCompleted) { if (_ClientWs.State == WebSocketState.Open) { Task.Run(() => { _Connected = true; Task.Run(() => DataReceiver(), _Token); ServerConnected?.Invoke(this, EventArgs.Empty); }, _Token); } else { _Connected = false; ServerDisconnected?.Invoke(this, EventArgs.Empty); } } else { _Connected = false; ServerDisconnected?.Invoke(this, EventArgs.Empty); } }
/// <summary> /// Disconnects from server /// </summary> /// <returns><c>true</c> if disconnect is OK, <c>false</c> otherwise.</returns> public virtual bool Disconnect() { if (Sender != null) { Sender.Close(); } Sender = null; if (fNetworkStream != null) { fNetworkStream.Close(); } fNetworkStream = null; if (ServerDisconnected != null) { ServerDisconnected.Invoke(); } if (Globals.Debug) { Console.WriteLine(Resources.Disconnected_from + " " + IpAddress + ":" + Port); } return(true); }
private void _client_ServerDisconnected(object sender, TcpServerDisconnectedEventArgs e) { if (!_isClose) { ServerDisconnected?.Invoke(sender, e); } }
public void OnServerStopped() { Debug.WriteLine("[INFO] MtClient::OnServerStopped"); Close(); ServerDisconnected?.Invoke(this, EventArgs.Empty); }
public void OnServerStopped() { Log.Debug("OnServerStopped: begin."); ServerDisconnected?.Invoke(this, EventArgs.Empty); Log.Debug("OnServerStopped: end."); }
private void Server_ConnetionClosed(object sender, UCBServerConnection e) { if (IdentifiedServers.ContainsKey(e)) { ServerDisconnected?.Invoke(this, IdentifiedServers[e]); IdentifiedServers.Remove(e); } }
private void OnDisconnect(Server server) { client.Mutex.WaitOne(); devices.Clear(); ServerDisconnected?.Invoke(server); client.Mutex.ReleaseMutex(); Log("Disconnected from " + Host + ":" + Port); }
internal void Start() { string ip = null; int port = -1; Common.ParseIpPort(PeerNode.IpPort, out ip, out port); if (PeerNode.Ssl) { _TcpClient = new WatsonTcpClient( ip, port, PeerNode.PfxCertificateFile, PeerNode.PfxCertificatePassword); Logger?.Invoke("[MeshClient] Starting TCP client with SSL to connect to " + ip + ":" + port); } else { _TcpClient = new WatsonTcpClient( ip, port); Logger?.Invoke("[MeshClient] Starting TCP client to connect to " + ip + ":" + port); } _TcpClient.AcceptInvalidCertificates = _Settings.AcceptInvalidCertificates; _TcpClient.MutuallyAuthenticate = _Settings.MutuallyAuthenticate; _TcpClient.StreamBufferSize = _Settings.StreamBufferSize; _TcpClient.AuthenticationRequested = MeshClientAuthenticationRequested; _TcpClient.AuthenticationSucceeded += MeshClientAuthenticationSucceeded; _TcpClient.AuthenticationFailure += MeshClientAuthenticationFailure; _TcpClient.ServerConnected += MeshClientServerConnected; _TcpClient.ServerDisconnected += MeshClientServerDisconnected; _TcpClient.StreamReceived += MeshClientStreamReceived; try { _TcpClient.Start(); } catch (SocketException) { Task unawaited = Task.Run(() => ReconnectToServer()); ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode)); } catch (Exception e) { Logger?.Invoke("[MeshClient] Client exception: " + Environment.NewLine + Common.SerializeJson(e, true)); Task unawaited = Task.Run(() => ReconnectToServer()); ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode)); } Logger?.Invoke("[MeshClient] Client started"); }
private void SetVisibleControl(bool state) { if (this.ServerDisconnected.InvokeRequired) { var d = new SetVisible(this.SetVisibleControl); ServerDisconnected.Invoke(d, state); } else { this.ServerDisconnected.Visible = state; } }
private async Task DataReceiver() { byte[] buffer = new byte[65536]; try { while (true) { if (_Token.IsCancellationRequested) { break; } MessageReceivedEventArgs msg = await MessageReadAsync(buffer); if (msg != null) { if (EnableStatistics) { _Stats.IncrementReceivedMessages(); _Stats.AddReceivedBytes(msg.Data.Count); } if (msg.MessageType != WebSocketMessageType.Close) { if (_AwaitingSyncResponseEvent != null) { _AwaitingSyncResponseEvent?.Invoke(this, msg); } else { MessageReceived?.Invoke(this, msg); } } } } } catch (OperationCanceledException) { Logger?.Invoke(_Header + "data receiver canceled"); } catch (WebSocketException) { Logger?.Invoke(_Header + "websocket disconnected"); } catch (Exception e) { Logger?.Invoke(_Header + "exception: " + Environment.NewLine + e.ToString()); } ServerDisconnected?.Invoke(this, EventArgs.Empty); }
//接收服务器响应线程函数 private void receiveResponseThreadFunction() { try { while (true) { //接收请求包 AbstractXiepPackage recvPackage = XiepIoHelper.ReceivePackage(_networkStream); if (recvPackage == null) { throw new IOException("获取数据包失败。"); } //如果是响应数据包 if (recvPackage is ResponsePackage) { ResponsePackage responsePackage = (ResponsePackage)recvPackage; String requestId = responsePackage.RequestId; lock (_mapRequestResponse) { if (_mapRequestResponse.ContainsKey(requestId)) { _mapRequestResponse.Remove(requestId); _mapRequestResponse.Add(requestId, responsePackage); } } } //如果是事件数据包 else if (recvPackage is EventPackage) { EventPackage eventPackage = (EventPackage)recvPackage; //触发收到服务器事件的事件 if (ServerEventCame != null) { ServerEventCame.BeginInvoke(this, new XiepClientEventArgs(eventPackage), new AsyncCallback(delegate(IAsyncResult iar) { }), null); } } } } catch { _networkStream = null; _socket = null; //触发与服务器连接断开事件 if (ServerDisconnected != null) { //ServerDisconnected.BeginInvoke(this, new System.EventArgs(), new AsyncCallback(delegate(IAsyncResult iar) { }), this); ServerDisconnected.Invoke(this, new System.EventArgs()); } } }
public GameClient(string address, int port) { _udp = new UdpClient(0) { Client = { Blocking = false } }; _target = new IPEndPoint(IPAddress.Parse(address), port); _server = new NetworkConnection(_udp, _target); _server.MessageReceived += (fromAddr, message) => MessageReceived?.Invoke(fromAddr, message); _server.ClientDisconnected += (fromAddr) => ServerDisconnected?.Invoke(fromAddr); _server.MessageAcked += (fromAddr, message) => MessageAcked?.Invoke(fromAddr, message); _server.MessageLost += (fromAddr, message) => MessageLost?.Invoke(fromAddr, message); _reliable = new ReliableConnection(_server); _reliable.ReliableMessageRecieved += (fromAddr, message) => ReliableMessageReceived?.Invoke(fromAddr, message); }
public async Task <bool> Connect(IServer connection) { if (connection != null) { try { var connected = await connection.ConnectAsync(); if (connected && connection.IsConnected) { if (ShouldUpdateActiveEnvironment) { SetActiveServer(connection); } } else { var result = PopupController?.ShowConnectionTimeoutConfirmation(connection.DisplayName); if (result == MessageBoxResult.Yes) { await Connect(connection); } else { ServerDisconnected?.Invoke(this, connection); } } OnPropertyChanged(() => connection.IsConnected); if (ServerConnected != null && connected && connection.IsConnected) { ServerConnected(this, connection); if (ShouldUpdateActiveEnvironment) { SetActiveServer(connection); } } } catch (Exception) { return(false); } return(true); } return(false); }
private async Task DataReceiver() { try { while (true) { if (_Token.IsCancellationRequested) { break; } MessageReceivedEventArgs msg = await MessageReadAsync(); if (msg != null) { if (EnableStatistics) { _Stats.IncrementReceivedMessages(); _Stats.AddReceivedBytes(msg.Data.Length); } Task internal_unawaited = Task.Run(() => InternalMessageReceived?.Invoke(this, msg), _Token); if (msg.MessageType != WebSocketMessageType.Close) { Task unawaited = Task.Run(() => MessageReceived?.Invoke(this, msg), _Token); } } } } catch (OperationCanceledException) { Logger?.Invoke(_Header + "data receiver canceled"); } catch (WebSocketException) { Logger?.Invoke(_Header + "websocket disconnected"); } catch (Exception e) { Logger?.Invoke(_Header + "exception: " + Environment.NewLine + e.ToString()); } ServerDisconnected?.Invoke(this, EventArgs.Empty); InternalServerDisconnected?.Invoke(this, EventArgs.Empty); }
protected override void ProcessMessage(IpcMessage message) { if (message is NetIpcLogMessage logMsg) { HandleLogMessage(logMsg); } else if (message.MessageType == IpcMessageType.NetIpcClientDisconnected) { ServerDisconnected?.Invoke(this, null); } else if (message.MessageType == IpcMessageType.NetIpcClientConnected) { ServerConnected?.Invoke(this, null); } else if (message is NetIpcAutoReconnectResponseMessage autoMsg) { HandleAutoReconnectStateMessage(autoMsg); } }
void UpdateRepositoryOnServerSaved(Guid savedServerID, bool isDeleted = false) { var shellViewModel = CustomContainer.Get <IShellViewModel>(); var currentServer = Servers.FirstOrDefault(server => server.EnvironmentID == savedServerID); var idx = -1; if (currentServer != null) { if (currentServer.IsConnected) { currentServer.Disconnect(); ServerDisconnected?.Invoke(this, currentServer); } idx = Servers.IndexOf(currentServer); currentServer.NetworkStateChanged -= OnServerOnNetworkStateChanged; Servers.Remove(currentServer); var environmentViewModel = shellViewModel?.ExplorerViewModel?.Environments?.FirstOrDefault(model => model.ResourceId == currentServer.EnvironmentID); if (environmentViewModel != null) { shellViewModel.ExplorerViewModel?.Environments?.Remove(environmentViewModel); } } if (isDeleted) { return; } var updatedServer = ServerRepository.Instance.Get(savedServerID); if (updatedServer == null) { return; } if (idx == -1) { idx = Servers.Count - 1; } updatedServer.NetworkStateChanged += OnServerOnNetworkStateChanged; Servers.Insert(idx, updatedServer); SelectedConnection = shellViewModel?.LocalhostServer; }
private void OnServerOnNetworkStateChanged(INetworkStateChangedEventArgs args, IServer server1) { if (args.State != ConnectionNetworkState.Connecting && args.State != ConnectionNetworkState.Connected && !server1.IsConnected) { if (SelectedConnection.EnvironmentID == server1.EnvironmentID) { if (!IsConnecting && server1.EnvironmentID == Guid.Empty) { ServerHasDisconnected(this, server1); } IsConnected = false; ServerDisconnected?.Invoke(this, SelectedConnection); PopupController?.Show(ErrorResource.ServerconnectionDropped + Environment.NewLine + ErrorResource.EnsureConnectionToServerWorking , ErrorResource.ServerDroppedErrorHeading, MessageBoxButton.OK, MessageBoxImage.Information, "", false, false, true, false, false, false); } } else { if (args.State == ConnectionNetworkState.Connected) { ServerReConnected?.Invoke(this, server1); } } }
private async Task DataReceiver() { string header = "[WatsonWsClient.DataReceiver " + _ServerIpPort + "] "; try { while (true) { if (_Token.IsCancellationRequested) { break; } byte[] data = await MessageReadAsync(); _Stats.ReceivedMessages = _Stats.ReceivedMessages + 1; _Stats.ReceivedBytes += data.Length; MessageReceived?.Invoke(this, new MessageReceivedEventArgs(_ServerIpPort, data)); } } catch (OperationCanceledException) { Logger?.Invoke(header + "canceled"); } catch (WebSocketException) { Logger?.Invoke(header + "websocket disconnected"); } catch (Exception e) { Logger?.Invoke(header + "exception: " + Environment.NewLine + e.ToString()); } _Connected = false; ServerDisconnected?.Invoke(this, EventArgs.Empty); }
internal void HandleServerDisconnected(object sender, DisconnectionEventArgs args) { WrappedEventHandler(() => ServerDisconnected?.Invoke(sender, args), "ServerDisconnected", sender); }
private async Task <bool> MessageWriteAsync(byte[] data, WebSocketMessageType msgType, CancellationToken token) { bool disconnectDetected = false; using (CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_Token, token)) { try { if (_ClientWs == null || _ClientWs.State != WebSocketState.Open) { Logger?.Invoke(_Header + "not connected"); disconnectDetected = true; return(false); } await _SendLock.WaitAsync(_Token); try { await _ClientWs.SendAsync(new ArraySegment <byte>(data, 0, data.Length), msgType, true, token); } catch { } finally { _SendLock.Release(); } if (EnableStatistics) { _Stats.IncrementSentMessages(); _Stats.AddSentBytes(data.Length); } return(true); } catch (TaskCanceledException) { if (_Token.IsCancellationRequested) { Logger?.Invoke(_Header + "canceled"); disconnectDetected = true; } else if (token.IsCancellationRequested) { Logger?.Invoke(_Header + "message send canceled"); } return(false); } catch (OperationCanceledException) { if (_Token.IsCancellationRequested) { Logger?.Invoke(_Header + "canceled"); disconnectDetected = true; } else if (token.IsCancellationRequested) { Logger?.Invoke(_Header + "message send canceled"); } return(false); } catch (WebSocketException) { Logger?.Invoke(_Header + "websocket disconnected"); disconnectDetected = true; return(false); } catch (ObjectDisposedException) { Logger?.Invoke(_Header + "disposed"); disconnectDetected = true; return(false); } catch (SocketException) { Logger?.Invoke(_Header + "socket disconnected"); disconnectDetected = true; return(false); } catch (InvalidOperationException) { Logger?.Invoke(_Header + "disconnected due to invalid operation"); disconnectDetected = true; return(false); } catch (IOException) { Logger?.Invoke(_Header + "IO disconnected"); disconnectDetected = true; return(false); } catch (Exception e) { Logger?.Invoke(_Header + "exception: " + Environment.NewLine + e.ToString()); disconnectDetected = true; return(false); } finally { if (disconnectDetected) { Dispose(); ServerDisconnected?.Invoke(this, EventArgs.Empty); InternalServerDisconnected?.Invoke(this, EventArgs.Empty); } } } }
protected override void ListeningLoop() { const int BUFFER_SIZE = 4096; char[] DELIM = new char[] { '$' }; StringBuilder backBuffer = new StringBuilder(); byte[] buffer = new byte[BUFFER_SIZE]; int received; try { while (true) { try { received = _Socket.Receive(buffer); } catch (SocketException) { ServerDisconnected.Invoke(); Stop(); break; } backBuffer.Append(Encoding.UTF8.GetString(buffer, 0, received)); if (received == BUFFER_SIZE) { continue; } string[] msgStr = backBuffer.ToString().Split(DELIM, StringSplitOptions.RemoveEmptyEntries); backBuffer = new StringBuilder(); foreach (string s in msgStr) { StringReader msgReader = new StringReader(s); ServerResponse msg = null; try { msg = (ServerResponse)_ReceiveMsgSerializer.Deserialize(msgReader); } catch (Exception) { Console.WriteLine("Got unexpected message!"); continue; } EnqueueMessage(msg); MessageReceivedInvoke(); } } } catch (ThreadAbortException) { } }
internal void HandleServerDisconnected(object sender, EventArgs args) { ServerDisconnected?.Invoke(sender, args); }
private async Task <bool> MessageWriteAsync(byte[] data) { string header = "[WatsonWsClient.DataReceiver " + _ServerIpPort + "] "; bool disconnectDetected = false; try { if (!_Connected || _ClientWs == null) { Logger?.Invoke(header + "not connected"); disconnectDetected = true; return(false); } await _SendLock.WaitAsync(_Token); try { await _ClientWs.SendAsync(new ArraySegment <byte>(data, 0, data.Length), WebSocketMessageType.Binary, true, CancellationToken.None); } finally { _SendLock.Release(); } _Stats.SentMessages += 1; _Stats.SentBytes += data.Length; return(true); } catch (OperationCanceledException) { Logger?.Invoke(header + "canceled"); disconnectDetected = true; return(false); } catch (WebSocketException) { Logger?.Invoke(header + "websocket disconnected"); disconnectDetected = true; return(false); } catch (ObjectDisposedException) { Logger?.Invoke(header + "disposed"); disconnectDetected = true; return(false); } catch (SocketException) { Logger?.Invoke(header + "socket disconnected"); disconnectDetected = true; return(false); } catch (InvalidOperationException) { Logger?.Invoke(header + "disconnected due to invalid operation"); disconnectDetected = true; return(false); } catch (IOException) { Logger?.Invoke(header + "IO disconnected"); disconnectDetected = true; return(false); } catch (Exception e) { Logger?.Invoke(header + "exception: " + Environment.NewLine + e.ToString()); disconnectDetected = true; return(false); } finally { if (disconnectDetected) { _Connected = false; Dispose(); ServerDisconnected?.Invoke(this, EventArgs.Empty); } } }
private void RaiseServerDisconnected() { ServerDisconnected?.Invoke(this, new TcpServerDisconnectedEventArgs(_remoteEndPoint, _localEndPoint)); }
private void Client_ServerDisconnected() { Logger.Debug("Server disconnected!"); ServerDisconnected?.Invoke(); }
protected virtual void OnServerDisconnected() { ServerDisconnected?.Invoke(this, new EventArgs()); }
private void OnServerDisconnected() { ServerDisconnected?.Invoke(this, new ServerDisconnected()); }