public override void OnResume() { Log.Info("Starting mouse move stream"); _mouseMoveStream?.Dispose(); _mouseMoveStream = this.GetAgent().FullDesktopClient.SendMouseMove(); base.OnResume(); }
public void Dispose() { try { _semaphoreSlim.Dispose(); channel?.ShutdownAsync(); stream?.Dispose(); } catch (Exception e) { OnError?.Invoke(this, $"Error during dispose: {e.Message}"); } }
public async Task DisconnectAsync(bool gracefulDisconnect) { IsConnected = false; IsShutdown = true; // we complete but no need to await the jobs _sendAnnouncementJobs.Complete(); _sendBlockJobs.Complete(); _sendTransactionJobs.Complete(); _announcementStreamCall?.Dispose(); _transactionStreamCall?.Dispose(); _blockStreamCall?.Dispose(); // send disconnect message if the peer is still connected and the connection // is stable. if (gracefulDisconnect && (_channel.State == ChannelState.Idle || _channel.State == ChannelState.Ready)) { GrpcRequest request = new GrpcRequest { ErrorMessage = "Error while sending disconnect." }; try { Metadata metadata = new Metadata { { GrpcConstants.SessionIdMetadataKey, OutboundSessionId } }; await RequestAsync( () => _client.DisconnectAsync(new DisconnectReason { Why = DisconnectReason.Types.Reason.Shutdown }, metadata), request); } catch (NetworkException) { // swallow the exception, we don't care because we're disconnecting. } } try { await _channel.ShutdownAsync(); } catch (InvalidOperationException) { // if channel already shutdown } }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { _timer?.Dispose(); _metricsUpdateChannel?.RequestStream.CompleteAsync().ConfigureAwait(false).GetAwaiter().GetResult(); _heatbeatChannel?.RequestStream.CompleteAsync().ConfigureAwait(false).GetAwaiter().GetResult(); _metricsUpdateChannel?.Dispose(); _heatbeatChannel?.Dispose(); _channel.ShutdownAsync().ConfigureAwait(false).GetAwaiter().GetResult(); _channel.Dispose(); } disposedValue = true; } }
/// <summary> /// Send a lib announcement to the peer using the stream call. /// Note: this method is not thread safe. /// </summary> public async Task SendLibAnnouncementAsync(LibAnnouncement libAnnouncement) { if (_libAnnouncementStreamCall == null) { _libAnnouncementStreamCall = _client.LibAnnouncementBroadcastStream(new Metadata { { GrpcConstants.SessionIdMetadataKey, OutboundSessionId } }); } try { await _libAnnouncementStreamCall.RequestStream.WriteAsync(libAnnouncement); } catch (RpcException) { _libAnnouncementStreamCall.Dispose(); _libAnnouncementStreamCall = null; throw; } }
/// <summary> /// Send a transaction to the peer using the stream call. /// Note: this method is not thread safe. /// </summary> private async Task SendTransactionAsync(Transaction transaction) { if (_transactionStreamCall == null) { _transactionStreamCall = _client.TransactionBroadcastStream(new Metadata { { GrpcConstants.SessionIdMetadataKey, OutboundSessionId } }); } try { await _transactionStreamCall.RequestStream.WriteAsync(transaction); } catch (RpcException) { _transactionStreamCall.Dispose(); _transactionStreamCall = null; throw; } }
/// <summary> /// Send a announcement to the peer using the stream call. /// Note: this method is not thread safe. /// </summary> private async Task SendAnnouncementAsync(BlockAnnouncement header) { if (_announcementStreamCall == null) { _announcementStreamCall = _client.AnnouncementBroadcastStream(new Metadata { { GrpcConstants.SessionIdMetadataKey, OutboundSessionId } }); } try { await _announcementStreamCall.RequestStream.WriteAsync(header); } catch (RpcException) { _announcementStreamCall.Dispose(); _announcementStreamCall = null; throw; } }
private async Task BroadcastBlockAsync(BlockWithTransactions blockWithTransactions) { if (_blockStreamCall == null) { _blockStreamCall = _client.BlockBroadcastStream(new Metadata { { GrpcConstants.SessionIdMetadataKey, OutboundSessionId } }); } try { await _blockStreamCall.RequestStream.WriteAsync(blockWithTransactions); } catch (RpcException) { _blockStreamCall.Dispose(); _blockStreamCall = null; throw; } }
public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { var session = m_channel.GetSession(); var rpc = new RpcTunnel <TRequest, TResponse>(session, method); var ret = new AsyncClientStreamingCall <TRequest, TResponse>(rpc, session, method); try { // Send request rpc.StartRequest(); // Wait response return(ret); } catch (Exception) { // Failed to request: unregister rpc ret.Dispose(); throw; } }
/// <summary> /// Send a transaction to the peer using the stream call. /// Note: this method is not thread safe. /// </summary> public async Task SendTransactionAsync(Transaction transaction) { if (!IsConnected) { return; } if (_transactionStreamCall == null) { _transactionStreamCall = _client.TransactionBroadcastStream(); } try { await _transactionStreamCall.RequestStream.WriteAsync(transaction); } catch (RpcException e) { _transactionStreamCall.Dispose(); _transactionStreamCall = null; HandleFailure(e, $"Error during transaction broadcast: {transaction.GetHash()}."); } }
/// <summary> /// Send a announcement to the peer using the stream call. /// Note: this method is not thread safe. /// </summary> public async Task SendAnnouncementAsync(BlockAnnouncement header) { if (!IsConnected) { return; } if (_announcementStreamCall == null) { _announcementStreamCall = _client.AnnouncementBroadcastStream(); } try { await _announcementStreamCall.RequestStream.WriteAsync(header); } catch (RpcException e) { _announcementStreamCall.Dispose(); _announcementStreamCall = null; HandleFailure(e, $"Error during announcement broadcast: {header.BlockHash}."); } }
public async Task SendBlockAsync(BlockWithTransactions blockWithTransactions) { if (!IsConnected) { return; } if (_blockStreamCall == null) { _blockStreamCall = _client.BlockBroadcastStream(); } try { await _blockStreamCall.RequestStream.WriteAsync(blockWithTransactions); } catch (RpcException e) { _blockStreamCall.Dispose(); _blockStreamCall = null; HandleFailure(e, $"Error during block broadcast: {blockWithTransactions.Header.GetHash()}."); } }
/// <summary> /// 指定されたメソッド呼び出しを登録します。 /// </summary> /// <typeparam name="TRequest">リクエストの型</typeparam> /// <typeparam name="TResponse">レスポンスの型</typeparam> /// <param name="call">呼び出しオブジェクト</param> /// <param name="method">メソッド</param> /// <param name="host">ホスト</param> /// <param name="options">オプション</param> /// <param name="performanceListener">パフォーマンスリスナー</param> /// <returns>呼び出しオブジェクト</returns> internal static AsyncClientStreamingCall <TRequest, TResponse> Regist <TRequest, TResponse>(AsyncClientStreamingCall <TRequest, TResponse> call, Method <TRequest, TResponse> method, string host, CallOptions options, GrpcClientPerformanceListener performanceListener) { GrpcCallInvokerContext.Releaser releaser = new GrpcCallInvokerContext.Releaser(delegate() { call.Dispose(); }); GrpcCallState state = new GrpcCallState(method, host, options); AsyncClientStreamingCall <TRequest, TResponse> wrap = new AsyncClientStreamingCall <TRequest, TResponse>( new RequestStreamWriter <TRequest>(call.RequestStream, method, host, options, state.OnRequestStreamCompleted, performanceListener) , call.ResponseAsync , call.ResponseHeadersAsync , call.GetStatus , call.GetTrailers , releaser.Dispose ); releaser.Target = wrap; GrpcCallInvokerContext.AddState(wrap, state); return(wrap); }
public override async Task DisposeAsync() { await base.DisposeAsync(); _writer.Dispose(); }
public void Dispose() { m_Call.Dispose(); }
public void Dispose() { _feedCpuInfoCall?.Dispose(); _timer?.Dispose(); }