/// <summary> /// Closes the connection to the client. Uses the status information from <see cref="Status"/>, if its CloseStatus /// has a value. Otherwise the specified CloseStatus and StatusDescription are used. /// </summary> /// <param name="closeStatus">Reason for closing the connection (if no Status.CloseStatus is set).</param> /// <param name="statusDescription">Description of the reason (if no Status.CloseStatus is set).</param> /// <returns></returns> public async Task Close(WebSocketCloseStatus closeStatus = WebSocketCloseStatus.Empty, string statusDescription = "") { if (_isClosed) { return; } _isClosed = true; // WebSocket must be in state "Open", "CloseReceived" or "CloseSent" if (_webSocket.State != WebSocketState.Open && _webSocket.State != WebSocketState.CloseReceived && _webSocket.State != WebSocketState.CloseSent) { return; } if (Status.CloseStatus.HasValue) { await _webSocket.CloseAsync(Status.CloseStatus.Value, Status.CloseStatusDescription, CancellationToken.None); } else { await _webSocket.CloseAsync(closeStatus, statusDescription, CancellationToken.None); } ConnectionClosed?.Invoke(this, EventArgs.Empty); }
public CommunicatingApplicationHook(System.Diagnostics.Process targetProcess) : base(targetProcess) { remoteProcess = new Native.Process.RemoteProcess(targetProcess); IPC.NamedPipes.NamedPipeServer server = new IPC.NamedPipes.NamedPipeServer(); PipeId = Guid.NewGuid().ToString(); Thread t = new Thread(() => { server.ConnectionRecieved += (s, e) => { connection = e.Value; while (e.Value.IsConnected) { var msg = e.Value.Receive(); if (e.Value.IsConnected && msg != null) { MessageReceived.RaiseEvent(this, msg); } } ConnectionClosed.RaiseEvent(this); }; server.Start(new IPC.NamedPipes.NamedPipeInitialisation(PipeId)); }); t.Start(); }
public void GetPhoneNumber_WhenCalledWithVoidMethod_Verify() { // Arrange, Act Instance.GetPhoneNumber(); // Assert this.ShouldSatisfyAllConditions( () => Records.Count.ShouldBe(15), () => Instance.Id.ShouldHaveSingleItem()); this.ShouldSatisfyAllConditions( () => Records.ShouldContain(Tuple.Create("Area", "0121", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Area", "0122", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Area", "0123", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Area", "0124", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3455", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3456", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3457", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3458", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3459", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "34510", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "34511", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "345", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Minor", "6789", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("ToString", "(012)345-6789--Area: 012Major: 345MinorMinor: 6789", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("FizzBuzz", "FizzBuzz", DbType.String, (Object)null)), () => ConnectionClosed.ShouldBeTrue(), () => ExecuteScalar.ShouldBeTrue(), () => ConnectionOpen.ShouldBeTrue(), () => Disposed.ShouldBe(1), () => Instance.Id.ShouldContain(1)); }
public virtual void RemoveConnection(IConnection connection, bool withError) { ClearListeners(connection); connection.Dispose(); ConnectionClosed?.Invoke(withError); }
// TO DO: Better error reporting on this method. public void Shutdown() { if (Client != null) { try { lock (ShutdownConnectionLock) { if (NetworkStream != null) { NetworkStream.Close(); NetworkStream.Dispose(); NetworkStream = null; } Client.Close(); Client = null; if (ConnectionClosed != null) { FrostbiteConnection.RaiseEvent(ConnectionClosed.GetInvocationList(), this); } } } catch (SocketException) { // TO DO: Error reporting, possibly in a log file. } catch (Exception e) { FrostbiteConnection.LogError("FrostbiteLayerConnection.Shutdown", "catch (Exception e)", e); } } }
public void ShutdownListener() { try { listener.Shutdown(SocketShutdown.Both); listener.Close(); ConnectionClosed?.Invoke(this, new SocketData { Data = "conexão fechada!" }); ConnectionClosed = null; ConnectionAccepted = null; DataReceived = null; } catch (ObjectDisposedException) { } catch (ArgumentNullException ane) { Console.WriteLine("ArgumentNullException : {0}", ane.ToString()); } catch (SocketException se) { Console.WriteLine("SocketException : {0}", se.ToString()); } catch (Exception e) { Console.WriteLine("Unexpected exception : {0}", e.ToString()); } }
public virtual async ValueTask RemoveConnectionAsync(IConnection connection, bool withError, CancellationToken cancellationToken = default) { ClearListeners(connection); await connection.DisposeAsync(); ConnectionClosed?.Invoke(withError); }
public void Dispose() { _intercomServer.ConnectionClosed -= OnConnectionClosed; ConnectionClosed?.Invoke(this, EventArgs.Empty); _intercomClient?.Dispose(); _intercomServer?.Dispose(); }
private async Task HandleTcpClientAsync(TcpClient tcpClient, int id, CancellationToken cancellationToken) { try { var tcpConnection = new TcpConnection(tcpClient); ConnectionAccepted?.Invoke(this, new ConnectionAcceptedEventArgs <TcpConnection> { Connection = tcpConnection, AuthenticatedUserName = null }); try { await tcpConnection.WhenClosed(); } finally { ConnectionClosed?.Invoke(this, new ConnectionEventArgs <TcpConnection> { Connection = tcpConnection }); } } finally { Task dummy; activeConnections.TryRemove(id, out dummy); } }
private void DataReceive() { while (Tcp?.Connected ?? false) { try { byte message = Reader.ReadByte(); switch (message) { case COMMAND_BYTE: byte command = Reader.ReadByte(); byte processNumber = Reader.ReadByte(); CommandReceived(command, processNumber); break; case TEXT_BYTE: string text = Reader.ReadString(); processNumber = Reader.ReadByte(); if (!string.IsNullOrEmpty(text)) { TextReceived(text, processNumber); } break; } } catch { ConnectionClosed?.Invoke(this, EventArgs.Empty); return; } } ConnectionClosed?.Invoke(this, EventArgs.Empty); }
private void Run() { try { while (true) { NetworkStream stream = _tcpClient.GetStream(); int messageId = stream.ReadByte(); Console.WriteLine(messageId); if (messageId == -1) { ConnectionClosed?.Invoke(this, new ConnectionClosedEventArgs()); break; } MessageReceived?.Invoke(this, new MessageReceivedEventArgs(messageId, stream)); } } catch (IOException e) { if (_manualRefusal) { Disconnected?.Invoke(this, new DisconnectedEventArgs()); } else { ConnectionRefused?.Invoke(this, new ConnectionRefusedEventArgs(e)); } } catch { ConnectionClosed?.Invoke(this, new ConnectionClosedEventArgs()); } }
/// <summary> /// Listens for messages from the server /// </summary> private void Listen() { string inputLine = null; while ((inputLine = reader.ReadLine()) != null) { try { if (inputLine[0] != '@') { ProcessData(inputLine, new Badge()); } else { ParseBagedData(inputLine); } } catch (Exception ex) { ExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex)); } } ConnectionClosed?.Invoke(this, new EventArgs()); }
public void Close() { _terminal?.ConsoleOutStream?.Close(); _reader?.Dispose(); ConnectionClosed?.Invoke(this, _terminal.ExitCode); }
internal void Stop(ConnectionLossType cause) { if (stopping) { return; } else { stopping = true; } ConnectionToken?.Cancel(); lastConnectionTestStopwatch?.Stop(); pollingService?.Change(-1, -1); connectionStatusService?.Change(-1, -1); if (connection.ConnectionState == ConnectionState.Connected) { Send(Protocol.Connection_Close); Send(Protocol.Connection_Close); } connection.UnInitialize(); ConnectionClosed?.Invoke(cause); connection.ConnectionState = ConnectionState.Offline; }
public void Disconnect() { if (_state == ConnectionState.Disconnected) { return; } _socket.Close(); _socket = null; _state = ConnectionState.Disconnected; try { //dispatch call into the proper thread _context.Post(s => { ConnectionClosed?.Invoke(); }, null); //ConnectionClosed?.Invoke(); } catch (Exception ex) { //dont trust user code Console.WriteLine("Calling client ConnectionClosed event handler threw an exception"); } }
private void HandleClose(ConnectionInfo info, IActorRef closeCommander, ConnectionClosed closedEvent) { SetStatus(ConnectionStatus.ShutdownRequested); if (closedEvent is Aborted) { if (traceLogging) { Log.Debug("Got Abort command. RESETing connection."); } DoCloseConnection(info, closeCommander, closedEvent); } else if (closedEvent is PeerClosed && info.KeepOpenOnPeerClosed) { // report that peer closed the connection info.Handler.Tell(PeerClosed.Instance); // used to check if peer already closed its side later peerClosed = true; Context.Become(PeerSentEOF(info)); } else if (IsWritePending) // finish writing first { UnsignDeathPact(); if (traceLogging) { Log.Debug("Got Close command but write is still pending."); } Context.Become(ClosingWithPendingWrite(info, closeCommander, closedEvent)); } else if (closedEvent is ConfirmedClosed) // shutdown output and wait for confirmation { if (traceLogging) { Log.Debug("Got ConfirmedClose command, sending FIN."); } // If peer closed first, the socket is now fully closed. // Also, if shutdownOutput threw an exception we expect this to be an indication // that the peer closed first or concurrently with this code running. if (peerClosed || !SafeShutdownOutput()) { DoCloseConnection(info, closeCommander, closedEvent); } else { Context.Become(Closing(info, closeCommander)); } } // close gracefully now else { if (traceLogging) { Log.Debug("Got Close command, closing connection."); } Socket.Shutdown(SocketShutdown.Both); DoCloseConnection(info, closeCommander, closedEvent); } }
private void Connection_ServiceClosed(AppServiceConnection sender, AppServiceClosedEventArgs args) { appServiceConnection.RequestReceived -= Connection_RequestReceived; appServiceConnection.ServiceClosed -= Connection_ServiceClosed; appServiceConnection = null; ConnectionClosed?.Invoke(this); }
protected virtual void OnConnectionClosed() { // DEBUG: Log connection closed. Log.Debug($"Connection to ('{_address}:{_port}') was closed."); ConnectionState = ClientConnectionState.Disconnected; ConnectionClosed?.Invoke(this, new EventArgs()); }
public void Close() { _port.Close(); if (!_port.IsOpen) { ConnectionClosed?.Invoke(this); } }
public MessageHandler(IChannel channel, MessageReceived <T> onMessage, ConnectionClosed <T> onConnectionClosed, ConnectionOpened <T> onConnectionOpened) { this.Channel = channel; this.OnMessage = onMessage; this.OnConnectionClosed = onConnectionClosed; this.OnConnectionOpened = onConnectionOpened; }
protected virtual void OnConnectionClosed() { State = ConnectionState.Closed; if (ConnectionClosed != null) { ConnectionClosed.call(this, EventArgs.Empty); } }
private void OnConnectionClosed(object sender, ConnectionClosedEventArgs args) { if (args.ClosedByPeer) { Log.ConnectionClosed(_logger, args.Error); _writer.TryWrite(ConnectCommand.Instance); } ConnectionClosed?.Invoke(sender, args); }
private void Close() { CustomTools.Console.DebugLog("Client::Close() Close client"); CloseWebSocket(); if (SendFromThread) { sendingQueue.Clear(); } ConnectionClosed.SafeInvoke(this); }
private void Handler_Closed(FtpSocketHandler handler) { m_apConnections.Remove(handler); numberOfConnections = m_apConnections.Count; Trace.WriteLine($"Remover a handler, current connection number is {numberOfConnections}", "Information"); ConnectionClosed?.Invoke(handler.Id); }
public void Close() { int exitCode = -1; if (_shellProcess != null && _shellProcess.HasExited) { exitCode = _shellProcess.ExitCode; } ConnectionClosed?.Invoke(this, exitCode); }
public void NotifyConnectionClosed(string connectionId) { SignalRConnection connection; if (connections.TryRemove(connectionId, out connection)) { connection.NotifyClosed(); ConnectionClosed?.Invoke(this, new ConnectionEventArgs <SignalRConnection>() { Connection = connection }); } }
void Close() { Unity.Console.DebugLog("Client::Close() Close client"); CloseWebSocket(); if (SendFromThread) { sendingQueue.Clear(); } if (!ConnectionClosed.IsNull()) { ConnectionClosed(this); } }
public void GetPhoneNumber_WhenCalled_Verify(bool voidMethod) { // Arrange, Act if (voidMethod) { Instance.GetPhoneNumber(); } else { Instance.SavePhoneNumber(); } // Assert this.ShouldSatisfyAllConditions( () => Instance.Id.ShouldHaveSingleItem(), () => Records.Count.ShouldBeGreaterThanOrEqualTo(2)); if (CheckParameter("True")) { Records.Count.ShouldBe(15); this.ShouldSatisfyAllConditions( () => Records.ShouldContain(Tuple.Create("Area", "0121", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Area", "0122", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Area", "0123", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Area", "0124", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3455", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3456", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3457", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3458", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "3459", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "34510", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "34511", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Major", "345", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("Minor", "6789", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("ToString", "(012)345-6789--Area: 012Major: 345MinorMinor: 6789", DbType.String, (Object)null)), () => Records.ShouldContain(Tuple.Create("FizzBuzz", "FizzBuzz", DbType.String, (Object)null)), () => ConnectionClosed.ShouldBeTrue(), () => ExecuteScalar.ShouldBeTrue(), () => ConnectionOpen.ShouldBeTrue(), () => Disposed.ShouldBe(1), () => Instance.Id.ShouldContain(1)); } if (CheckParameter("False")) { this.ShouldSatisfyAllConditions( () => ShouldContain(Records, "Parameter1", "", DbType.String, (string)null), () => ShouldContain(Records, "FizzBuzz", "FizzBuzz", DbType.String, (string)null), () => Instance.Id.ShouldContain(111)); } }
// TODO: Detect when WCF sends a closed signal public IServerService Connect(IClientCallback clientCallback) { InstanceContext context = new InstanceContext(clientCallback); DuplexChannelFactory <IServerService> channelFactory = new DuplexChannelFactory <IServerService>(context, new NetNamedPipeBinding(), new EndpointAddress(ConnectionConstants.EndpointFullAddress)); channelFactory.Closed += (sender, args) => ConnectionClosed?.Invoke(this, EventArgs.Empty); channelFactory.Faulted += (sender, args) => ConnectionFaulted?.Invoke(this, EventArgs.Empty); IServerService service = channelFactory.CreateChannel(); service.Connect(); return(service); }
private async void runReceiveLoop(CancellationToken token) { try { byte[] buffer = new byte[32 * 1 << 20]; while (!_disposed && _client != null && _client.Connected) { token.ThrowIfCancellationRequested(); int totalRxed = 0; int justRxed = 0; do { if (buffer.Length - totalRxed <= 0) { throw new InvalidOperationException("Message too large to receive!"); } justRxed = await _client.GetStream().ReadAsync(buffer, totalRxed, buffer.Length - totalRxed, token); totalRxed += justRxed; } while (justRxed == _client.ReceiveBufferSize); if (totalRxed > 0) { try { RpcResponse response = MessagePackSerializer.Deserialize <RpcResponse>(buffer); response.ResultAsJson = JsonConvert.SerializeObject(response.Result); taskForRequest(response.MsgId).SetResult(response); } catch (Exception ex) when(!(ex is OperationCanceledException) || !(ex is ObjectDisposedException) || !(ex is IOException)) // MessagePack failure { _client.Dispose(); _client = null; failAllTasks(ex.Message); } } } } catch (Exception ex) when(ex is OperationCanceledException || ex is ObjectDisposedException || ex is IOException) { } finally { failAllTasks("Client closed"); ConnectionClosed?.Invoke(this, EventArgs.Empty); } }
private void HandleConnectionClosed(ConnectionClosed message) { Console.WriteLine("Connection closed"); Context.Stop(Self); Context.Parent.Tell(message); }