public override Task <DisconnectResponse> Disconnect(DisconnectRequest request, ServerCallContext context) { var response = new DisconnectResponse() { ResponseBase = CreateResponseBase() }; RunCommand(nameof(Disconnect), () => connectionsService.RemoveConnection(request.RequestBase), request.RequestBase, response.ResponseBase); return(Task.FromResult(response)); }
private void OnDisconnect(DisconnectResponse disconnectResponse) { if (disconnectResponse.Username != _username) { _uiFactory.StartNew(() => { if (_connectedClients.Contains(disconnectResponse.Username)) { _connectedClients.Remove(disconnectResponse.Username); } }); } }
public void HandleDisconnectRequest(DisconnectRequest msg) { _clients.Remove(Sender); var response = new DisconnectResponse { Username = msg.Username }; foreach (var client in _clients) { client.Tell(response, Self); } }
private static void OnReceive([CanBeNull] Message message) { if (message == null) { return; } LogResponse logResponse = message as LogResponse; if (logResponse != null && logResponse.Logs != null) { ConsoleTextWriter.Default.Context.Invoke( () => { if (Console.CursorLeft != 0) { ConsoleTextWriter.Default.WriteLine(); } foreach (Log log in logResponse.Logs) { Debug.Assert(log != null); log.WriteTo(ConsoleTextWriter.Default, _logFormatBuilder); } }); return; } DisconnectResponse disconnectResponse = message as DisconnectResponse; if (disconnectResponse == null) { return; } ConsoleTextWriter.Default.WriteLine(); ConsoleTextWriter.Default.WriteLine("Disconnected"); }
/** * Leave a room the user is currently in. */ public async Task <DisconnectResponse> Disconnect(DisconnectRequest payload) { try { var response = new DisconnectResponse(); User user = await _userRepository.FindRoomOfUserBySocketId(payload.socketId); if (user == null) { throw new ApplicationError("[UserService.Disconnect]", 1); } if (user.room == null) { throw new ApplicationError("[UserService.Disconnect]", 2); } var room = user.room; var users = await _userRepository.FindAllByRoomId(room.id); user.room = null; response.roomIdentifier = room.identifier; response.users = users.Where( (roomUser) => roomUser.socketId != payload.socketId ); await _unitOfWork.Save(); return(response); } catch (Exception e) { throw e; } }
internal void DisconnectIndication(DisconnectIndication indication) { Connection connection = Connections.GetConnectionByPLCI(indication.Identifier.PLCI); Debug.Assert(connection != null, "Connecion needs to exist at this point."); DisconnectResponse response = new DisconnectResponse(indication); _application.SendMessage(response); connection.Status = ConnectionStatus.Disconnected; Connections.InternalRemove(indication.Identifier.PLCI); //connection.Dispose(); }
private void HandleDisconnectResponse(DisconnectResponse msg) { Console.WriteLine("{0}: Has left the conversation.", msg.Username); }
/// <summary> /// Initializes a new instance of the <see cref="NamedPipeClient" /> class. /// </summary> /// <param name="description">The client description.</param> /// <param name="server">The server.</param> /// <param name="onReceive">The action to call on receipt of a message.</param> /// <param name="token">The token.</param> private NamedPipeClient( [NotNull] string description, [NotNull] NamedPipeServerInfo server, [NotNull] Action <Message> onReceive, CancellationToken token = default(CancellationToken)) { if (description == null) { throw new ArgumentNullException("description"); } if (server == null) { throw new ArgumentNullException("server"); } if (onReceive == null) { throw new ArgumentNullException("onReceive"); } _server = server; _cancellationTokenSource = new CancellationTokenSource(); CancellationToken disposeToken = _cancellationTokenSource.Token; _clientTask = Task.Run( async() => { try { using (ITokenSource tokenSource = token.CreateLinked(disposeToken)) using ( OverlappingPipeClientStream stream = new OverlappingPipeClientStream( _server.Host, _server.FullName, PipeTransmissionMode.Message)) { _state = PipeState.Open; token = tokenSource.Token; // We need to support cancelling the connect. await stream.Connect(token).ConfigureAwait(false); ConnectResponse connectResponse = null; DisconnectResponse disconnectResponse = null; if (!token.IsCancellationRequested) { // Set the stream. _stream = stream; _state = PipeState.AwaitingConnect; // Kick off a connect request, but don't wait for it's result as we're the task that will receive it! ConnectRequest connectRequest = new ConnectRequest(description); await stream.WriteAsync(connectRequest.Serialize(), token).ConfigureAwait(false); // Keep going as long as we're connected. try { while (stream.IsConnected && !disposeToken.IsCancellationRequested) { // Read data in. byte[] data = await stream.ReadAsync(disposeToken).ConfigureAwait(false); if (data == null) { break; } // Deserialize the incoming message. Message message = Message.Deserialize(data); if (connectResponse == null) { // We require a connect response to start connectResponse = message as ConnectResponse; if (connectResponse == null || connectResponse.ID != connectRequest.ID) { break; } _state = PipeState.Connected; _serviceName = connectResponse.ServiceName; Log.Add( LoggingLevel.Notification, () => ClientResources.Not_NamedPipeClient_Connection, connectResponse.ServiceName); TaskCompletionSource <NamedPipeClient> ccs = Interlocked.Exchange(ref _connectionCompletionSource, null); if (ccs != null) { ccs.TrySetResult(this); } // Observer the message. onReceive(message); continue; } // Check for disconnect, we don't observe the message until the disconnect is complete. disconnectResponse = message as DisconnectResponse; if (disconnectResponse != null) { break; } // Observe the message. onReceive(message); Response response = message as Response; if (response == null) { continue; } ConnectedCommand connectedCommand; // Check for cancellation responses. CommandCancelResponse cancelResponse = response as CommandCancelResponse; if (cancelResponse != null) { // Cancel the associated request if (_commandRequests.TryGetValue( cancelResponse.CancelledCommandId, out connectedCommand)) { // ReSharper disable once PossibleNullReferenceException connectedCommand.Cancel(cancelResponse); } } // And fall through to complete the response... // Find command the response is related to, and notify it of the response. if (!_commandRequests.TryGetValue(response.ID, out connectedCommand)) { continue; } Debug.Assert(connectedCommand != null); if (connectedCommand.Received(response)) { _commandRequests.TryRemove(response.ID, out connectedCommand); } } } catch (TaskCanceledException) { } } // If we're still connected, and we haven't received a disconnect response, try to send a disconnect request. if (stream.IsConnected && disconnectResponse == null) { CancellationTokenSource cts = token.IsCancellationRequested ? new CancellationTokenSource(500) : null; try { CancellationToken t = cts != null ? cts.Token : token; // Try to send disconnect request. // ReSharper disable once PossibleNullReferenceException await Send(new DisconnectRequest(), t) .ToTask(t) .ConfigureAwait(false); } catch (TaskCanceledException) { } finally { if (cts != null) { cts.Dispose(); } } } // Remove the stream. _stream = null; _state = PipeState.Closed; _serviceName = null; // If we had a disconnect message observe it now that the disconnect has been actioned, // this prevents the receiver thinking the connection is still active. if (disconnectResponse != null) { onReceive(disconnectResponse); ConnectedCommand connectedCommand; if (_commandRequests.TryGetValue(disconnectResponse.ID, out connectedCommand)) { Debug.Assert(connectedCommand != null); if (connectedCommand.Received(disconnectResponse)) { _commandRequests.TryRemove(disconnectResponse.ID, out connectedCommand); } } } } } catch (IOException ioe) { if (!token.IsCancellationRequested) { // Common exception caused by sudden disconnect, lower level Log.Add( ioe, LoggingLevel.Information, () => ClientResources.Err_NamedPipeClient_Failed); } } catch (Exception exception) { TaskCanceledException tce = exception as TaskCanceledException; TaskCompletionSource <NamedPipeClient> ccs = Interlocked.Exchange( ref _connectionCompletionSource, null); if (ccs != null) { if (tce != null) { ccs.TrySetCanceled(); } else { ccs.TrySetException(exception); } } // We only log if this wasn't a cancellation exception. if (tce == null && !token.IsCancellationRequested) { Log.Add( exception, LoggingLevel.Error, () => ClientResources.Err_NamedPipeClient_Failed); } } finally { Dispose(); } }, disposeToken); }
public static unsafe void Write(global::Improbable.Worker.Internal.GcHandlePool _pool, DisconnectResponse _data, global::Improbable.Worker.CInterop.SchemaObject _obj) { }
public void Handle(DisconnectResponse message) { OnDisconnect?.Invoke(message); }