/// <summary> /// Open serial port /// </summary> public void Connect() { logger.Debug("Connecting to device..."); try { port.Open(); if (port.IsOpen == true) { logger.Info("Device connected."); Connected?.Invoke(); } else { logger.Info("Device not connected."); Disconnected?.Invoke(); } } catch (System.Exception ex) { throw new CommunicationException("Port opening failed. Please check port name.", ex); } }
//called once a client disconnects from the server private void OnDisconnected(INetworkPlayer player) { if (logger.LogEnabled()) { logger.Log("Server disconnect client:" + player); } // set the flag first so we dont try to send any messages to the disconnected // connection as they wouldn't get them player.MarkAsDisconnected(); RemoveConnection(player); Disconnected?.Invoke(player); player.DestroyOwnedObjects(); player.Identity = null; if (player == LocalPlayer) { LocalPlayer = null; } }
public void Disconnect(bool notify) { if (IsConnected) { IsConnected = false; RemoteIP = null; _encryption = null; try { _socket.Shutdown(SocketShutdown.Both); } catch (Exception ex) { NotifyError(ex); } _socket.Dispose(); _socket = null; if (notify) { Disconnected?.Invoke(this, EventArgs.Empty); } } }
private void HookNotifications() { Socket.Connected += (socket, address) => { Connected?.Invoke(this, address); }; Socket.Disconnected += (socket, exception) => { Disconnected?.Invoke(this, exception); }; Socket.MessageReceived += (s, message) => { var msg = FormatReceivedMessage(message); if (msg != null) { MessageReceived?.Invoke(this, msg); } }; Socket.MessageSent += socket => { MessageSent?.Invoke(this); }; }
public void Disconnect(bool error) { if (Interlocked.Exchange(ref disposed, 1) == 0) { tcp.Close(); Disconnected?.Invoke(this, error); lock (missions_global) { foreach (UInt256 hash in missions) { missions_global.Remove(hash); } } if (protocolThread != Thread.CurrentThread && !protocolThread.ThreadState.HasFlag(ThreadState.Unstarted)) { protocolThread.Join(); } if (!sendThread.ThreadState.HasFlag(ThreadState.Unstarted)) { sendThread.Join(); } } }
private void OnConnectionDisconnected(object sender, EventArgs e) { if (!_isDisconnecting) { _isDisconnecting = true; if (sender == _sender) { _receiver.Disconnect(); } if (sender == _receiver) { _sender.Disconnect(); } IsConnected = false; Disconnected?.Invoke(this, DisconnectedEventArgs.Empty); _isDisconnecting = false; } }
public async Task <InvokeResult> RefreshAdaptersAsync() { if (!_isConnected) { await _wifiAdapter.ScanAsync(); foreach (var networks in _wifiAdapter.NetworkReport.AvailableNetworks) { if (networks.Ssid.StartsWith("TELLO")) { await _wifiAdapter.ConnectAsync(networks, WiFiReconnectionKind.Automatic); _dispatcherService.Invoke(() => Connected?.Invoke(this, new WiFiConnection(networks))); Debug.WriteLine("CONNEcTED TO TELLO!"); _isConnected = true; return(InvokeResult.Success); } } } _dispatcherService.Invoke(() => Disconnected?.Invoke(this, null)); return(InvokeResult.FromError("Could not connected")); }
private void ThreadCheckSerialOpen() { while (isThreadCheckSerialOpen) { Thread.Sleep(sleepTimeCheck); try { if (serialPort == null || !serialPort.IsOpen) { Debug.WriteLine("seriaport disconnected"); Disconnected?.Invoke(this, new SerialCommDisconnectedEventArgs { DeviceID = _deviceID }); break; } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } } }
protected void OnPipeData(IAsyncResult ar) { var conn = ar.AsyncState as PipeConnection; try { DataReceived?.Invoke(conn, conn.EnsureMessageComplete(conn.Pipe.EndRead(ar))); } catch { if (!conn.Pipe.IsConnected) { lock (Pipes) { Pipes.Remove(conn.Pipe); } Disconnected?.Invoke(conn); conn.Dispose(); return; } } BeginPipeRead(conn); }
public virtual void Disconnect(bool error) { if (Interlocked.Exchange(ref disposed, 1) == 0) { Disconnected?.Invoke(this, error); bool needSync = false; lock (missions_global) lock (missions) if (missions.Count > 0) { missions_global.ExceptWith(missions); needSync = true; } if (needSync) { lock (localNode.connectedPeers) foreach (RemoteNode node in localNode.connectedPeers) { node.EnqueueMessage("getblocks", GetBlocksPayload.Create(Blockchain.Default.CurrentBlockHash), true); } } } }
private async void ReceiveLoop(TcpClient tcpClient) { int connectionId = NextConnectionId(); clients.Add(connectionId, tcpClient); try { // someone connected, raise event Connected?.Invoke(connectionId); using (Stream networkStream = tcpClient.GetStream()) { while (true) { byte[] data = await ReadMessageAsync(networkStream); if (data == null) { break; } // we received some data, raise event ReceivedData?.Invoke(connectionId, data); } } } catch (Exception exception) { ReceivedError?.Invoke(connectionId, exception); } finally { clients.Remove(connectionId); Disconnected?.Invoke(connectionId); } }
private void OnConnectionError() { if (disposedValue) { return; } lock (threadLock) { Disconnected?.Invoke(this, null); ISLogger.Write($"NamedIpc->Reconnecting to service"); while (!disposedValue) { try { if (!clientRead.IsConnected) { clientRead.Connect(500); } if (!clientWrite.IsConnected) { clientWrite.Connect(500); } } catch (Exception) { } } if (disposedValue) { return; } Connected?.Invoke(this, null); ISLogger.Write($"NamedIpc->Reconnected to service"); clientRead.BeginRead(clientBuff, 0, clientBuff.Length, ClientReadCallback, null); } }
public ConnectionHandler(string host, int port) { Host = host ?? throw new ArgumentNullException(nameof(host)); Port = port; Connection = new IPConnection(); Connection.SetAutoReconnect(true); Connection.Connected += (s, e) => { IsConnceted = true; Connection.Enumerate(); var reason = e switch { IPConnection.CONNECT_REASON_REQUEST => ConnectedReason.Requested, IPConnection.CONNECT_REASON_AUTO_RECONNECT => ConnectedReason.Reconnect, _ => ConnectedReason.Unknown, }; Connected?.Invoke(this, new ConnectedEventArgs(reason)); }; Connection.Disconnected += (s, e) => { IsConnceted = false; var reason = e switch { IPConnection.DISCONNECT_REASON_REQUEST => DisconnectedReason.RequestedFromSelf, IPConnection.DISCONNECT_REASON_SHUTDOWN => DisconnectedReason.RequestedFromEndpoint, IPConnection.DISCONNECT_REASON_ERROR => DisconnectedReason.Timeout, _ => DisconnectedReason.Unknown, }; Disconnected?.Invoke(this, new DisconnectedEventArgs(reason)); }; Connection.EnumerateCallback += (s, uid, cu, p, hV, fV, dI, eT) => { Enumerate?.Invoke(this, new EnumerateEventArgs( new TinkerforgeDeviceInfo(uid, cu, p, hV, fV, dI), eT)); }; }
private void Release(bool userRequestedDisconnect) { lock (netLock) { if (cancellationToken != null) { cancellationToken.Dispose(); cancellationToken = null; } if (netWriter != null) { netWriter.Dispose(); netWriter = null; } if (netReader != null) { netReader.Dispose(); netReader = null; } if (netStream != null) { netStream.Dispose(); netStream = null; } if (socket != null) { socket.Dispose(); socket = null; } } Disconnected?.Invoke(this, new DisconnectedEventArgs(userRequestedDisconnect)); }
private async Task CloseAsync(Exception e, bool awaitAll) { if (!IsOpen) { return; } foreach (OwnTcpServerConnection connection in connections.ToArray()) { await CloseConnection(connection).ConfigureAwait(false); } isOpen = false; listener.Stop(); await processQueue.End(); Task raiseTask = RaiseDisconnected(); if (awaitAll) { await raiseTask.ConfigureAwait(false); } async Task RaiseDisconnected() { if (openTask != null) { await openTask.ConfigureAwait(false); } if (e != null) { } Disconnected?.Invoke(this, new DisconnectedEventArgs(e == null, e)); } }
/// <summary> /// Connect this instance to the specified URL, and authenticate (if needed) with the specified password /// </summary> /// <param name="url">Server URL in standard URL format.</param> /// <param name="password">Server password</param> public void Connect(string url, string password) { if (!url.ToLower().StartsWith(WEBSOCKET_URL_PREFIX)) { throw new ArgumentException($"Invalid url, must start with '{WEBSOCKET_URL_PREFIX}'"); } if (WSConnection != null && WSConnection.IsAlive) { Disconnect(); } WSConnection = new WebSocket(url) { WaitTime = wsTimeout }; WSConnection.OnMessage += WebsocketMessageHandler; WSConnection.OnClose += (s, e) => { Disconnected?.Invoke(this, e); }; WSConnection.Connect(); if (!WSConnection.IsAlive) { return; } OBSAuthInfo authInfo = GetAuthInfo(); if (authInfo.AuthRequired) { Authenticate(password, authInfo); } Connected?.Invoke(this, null); }
public static async Task <ConnectStatus> Connect(string host) { TcpClient tcp = null; try { tcp = new TcpClient(); await tcp.ConnectAsync(host ?? Protocol.Localhost, Protocol.Port); } catch { tcp?.Dispose(); return(ConnectStatus.Failed); } AlebClient.LogCommunication = true; Server = new AlebClient(tcp); Server.MessageReceived += Received; Server.Disconnected += _ => Disconnected?.Invoke(); Server.Name = "Server"; Task <Message> VersionTask = Register("Version"); Server.Run(); await VersionTask; if (Convert.ToInt32((await VersionTask).Args[0]) != Protocol.Version) { Server.Dispose(); Server = null; return(ConnectStatus.VersionMismatch); } return(ConnectStatus.Success); }
public API(FadeProxyClient proxy, Mode mode = Mode.BOT) { this.mode = mode; // Depedency injection Account = new Account(this); _proxy = proxy; _vanillaClient = new VanillaClient(this, proxy); Account.LoginSucceed += (s, e) => Connect(); _vanillaClient.Disconnected += (s, e) => Disconnected?.Invoke(s, e); _vanillaClient.HeroInited += (s, e) => { HeroInited?.Invoke(s, e); if (LoginTime == DateTime.MinValue) { LoginTime = DateTime.Now; } }; _vanillaClient.Attacked += (s, e) => Attacked?.Invoke(s, e); _vanillaClient.ShipMoving += (s, e) => ShipMoving?.Invoke(s, e); _vanillaClient.Destroyed += (s, e) => Destroyed?.Invoke(s, e); }
public virtual void Disconnect(bool error) { TR.Enter(); if (Interlocked.Exchange(ref disposed, 1) == 0) { Disconnected?.Invoke(this, error); bool needSync = false; lock (missions_global) lock (missions) if (missions.Count > 0) { foreach (UInt256 hash in missions) { missions_global.Remove(hash); } needSync = true; } if (needSync) { localNode.RequestGetBlocks(); } } TR.Exit(); }
public async Task <bool> DisconnectAsync(CancellationTokenSource tokenSource, bool reconnect) { if (tokenSource == null) { tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10)); } if (Client == null || string.IsNullOrEmpty(ClientUniqueId)) { return(false); } while (!tokenSource.Token.IsCancellationRequested) { if (Client.GetStream().DataAvailable) { await Task.Delay(1).ConfigureAwait(false); continue; } Client.Close(); Client?.Dispose(); break; } tokenSource.Dispose(); lock (CoreServerBase.ConnectedClients) { if (CoreServerBase.ConnectedClients.ContainsKey(ClientUniqueId)) { CoreServerBase.ConnectedClients.TryRemove(ClientUniqueId, out _); } } Disconnected?.Invoke(this, new OnDisconnectedEventArgs(ClientUniqueId, DateTime.Now, reconnect)); return(true); }
private async Task DisconnectInternalAsync(Task sender, Exception exception) { InitiateDisconnect(); var clientWasConnected = IsConnected; IsConnected = false; try { await WaitForTaskAsync(_packetReceiverTask, sender).ConfigureAwait(false); await WaitForTaskAsync(_keepAliveMessageSenderTask, sender).ConfigureAwait(false); if (_adapter != null) { await _adapter.DisconnectAsync(_options.CommunicationTimeout, CancellationToken.None).ConfigureAwait(false); } _logger.Verbose("Disconnected from adapter."); } catch (Exception adapterException) { _logger.Warning(adapterException, "Error while disconnecting from adapter."); } finally { _adapter?.Dispose(); _adapter = null; _cancellationTokenSource?.Dispose(); _cancellationTokenSource = null; _cleanDisconnectInitiated = false; _logger.Info("Disconnected."); Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected, exception)); } }
/// <inheritdoc/> public void Disconnect(DisconnectedEventArgs e = null) { var didDisconnect = false; if (!_isDisconnecting) { _isDisconnecting = true; try { try { if (_sender != null) { _sender.Close(); _sender.Dispose(); didDisconnect = true; } } catch (Exception) { } _sender = null; if (didDisconnect) { _connectedEvent.Reset(); Disconnected?.Invoke(this, e ?? DisconnectedEventArgs.Empty); } } finally { _isDisconnecting = false; } } }
public void Disconnect() { if (!IsConnected) { return; } _remoteAddress = null; _remotePort = 0; disconnectTimer.Stop(); backlog.Clear(); currentPacket.Clear(); try { socket.Disconnect(false); socket = new Socket(SocketType.Stream, ProtocolType.Tcp); } catch (Exception ex) { Error?.Invoke(this, new ExceptionEventArgs(ex)); return; } Disconnected?.Invoke(this, EventArgs.Empty); }
private void HandleDisconnect(bool remote) { /* * Disconnect paths: * pre: receive handler running, send possible in progress * - local disconnect: * - DisconnectAsync * -> cancel token * ReceiveHandler * -> HandleDisconnect(remote = !token.canceled) * - socket.close * - event disconnected * - remote disconnect * - socket loses connection * ReceiveHandler * -> HandleDisconnect(remote = !token.canceled) * - event disconnected */ _socket.Close(); Disconnected?.Invoke(this, new DisconnectedArgs(remote)); }
private void ProcessRequests() { try { foreach (Request request in RequestQueue.ToArray()) { string serializedRequest = JsonConvert.SerializeObject(request); this.OutputStreamWriter.WriteLine(Utils.Base64Encode(serializedRequest)); this.OutputStreamWriter.Flush(); RequestQueue.Remove(request); } } catch (Exception) { Utils.LogLine("Błąd podczas wysyłania. Odświeżanie połączenia..."); RequestQueue.Clear(); Disconnected?.Invoke(); OutputStreamWriter = null; WaitForConnection(); } }
public void Init(string clientId, IMqttClientOptions mqttClientOptions) { try { this.mqttClientOptions = mqttClientOptions; var factory = new MqttFactory(); _mqttClient = factory.CreateMqttClient(); _mqttClient.ConnectedHandler = new MqttConnectedHandler(mqttClientConnectedEventArgs => { Connected?.Invoke(this, mqttClientConnectedEventArgs); }); _mqttClient.DisconnectedHandler = new MqttDisconnectedHandler(disconnectEventArgs => { Disconnected?.Invoke(this, disconnectEventArgs); }); _mqttClient.ApplicationMessageReceivedHandler = new MqttMessageReceivedHandler(messageReceivedArgs => { MessageReceived?.Invoke(this, messageReceivedArgs); }); } catch (Exception ex) { } }
void disconnectSP() { if (OnVirtualChannelCheck != null) { if (OnVirtualChannelCheck(debugChannelAddressesCB.Text)) { connectB_Text = "Connect"; connectB_ForeColor = Color.Black; Disconnected?.Invoke(this, new EventArgs()); VirutualChannelDisconnected?.Invoke(debugChannelAddressesCB.Text); return; } } try { Channel.Close(); Channel = null; } catch { } hasUiUpdate = true; connectB_Text = "Connect"; connectB_ForeColor = Color.Black; Disconnected?.Invoke(this, new EventArgs()); }
private void AcceptConnections(IAsyncResult result) { var resultWrapper = (Client)result.AsyncState; try { resultWrapper.ReplaceSslStream(result, m_Socket); resultWrapper.BeginAuthenticateAsServer(EndAuthenticate); m_Socket.BeginAccept(AcceptConnections, new Client()); } catch (Exception e) { Console.WriteLine(e); if (e.InnerException != null) { Console.WriteLine(e.InnerException); } Disconnected?.Invoke(this, resultWrapper); resultWrapper.CloseAndDisposeSslStream(); } }
private protected void Disconnect(DisconnectReason reason) { if (_clientSocket != null && _state != 0) { if (reason != DisconnectReason.Aborted && reason != DisconnectReason.Error) { Send(CommandID.DISCONNECT, new byte[1] { 255 }, 0, 1); } _state = 0; try { _clientSocket.Shutdown(SocketShutdown.Both); _clientSocket.Close(CLOSE_TIMEOUT); } catch { /* IGNORE */ } _clientSocket = null; Disconnected?.Invoke(this, reason); } }
private void HandleRequest(RequestData request) { switch (request.Request) { case Request.Disconnect: // server closed or kicked player client?.Close(); server?.Close(); client = null; server = null; Disconnected?.Invoke(this, EventArgs.Empty); break; case Request.Heartbeat: // TODO break; default: // all other requests can not be send to a client throw new ExceptionFreeserf(ErrorSystemType.Network, $"Request {request.ToString()} can not be send to client."); } RespondToRequest(request); }