/// <summary> /// This helper ensures we invalidate the _currentCall state if we want to throw canceled. /// </summary> private void ThrowIfCancellationRequested(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { _currentCall?.Dispose(); _currentCall = null; cancellationToken.ThrowIfCancellationRequested(); } }
/// <exclude /> public static async Task <IAsyncEnumerable <T> > GetServerStreamingCallResultAsync <T>( AsyncServerStreamingCall <Message <T> > call, CallContext?context, CancellationToken token) { try { if (context != null && !token.IsCancellationRequested) { var headers = await call.ResponseHeadersAsync.ConfigureAwait(false); context.ServerResponse = new ServerResponse( headers, call.GetStatus, call.GetTrailers); } } catch { call.Dispose(); throw; } return(ReadServerStreamingCallResultAsync(call, context, token)); }
public Task DisconnectAsync() { _cts.Cancel(); _call?.Dispose(); return(Task.CompletedTask); }
public void Dispose() { _cts?.Cancel(); _cts?.Dispose(); _stream?.Dispose(); channel?.Dispose(); }
public void Dispose() { _cts?.Cancel(); _cts?.Dispose(); _stream?.Dispose(); channel?.ShutdownAsync(); }
public void Shutdown() { Logger.Info("Shutting down..."); _client.Quit(new QuitRequest()); _commandStream?.Dispose(); _channel.ShutdownAsync().Wait(); Logger.Info("All down."); }
public async Task DisconnectAsync() { _cts.Cancel(); _call?.Dispose(); if (_channel != null) { await _channelFactory.DisposeAsync(_channel); } }
public async Task DisconnectAsync() { _cts.Cancel(); _call?.Dispose(); if (_channel != null) { await _channel.ShutdownAsync(); } }
/// <summary> /// </summary> public void Close() { if (IsClosed) { return; } IsClosed = true; _currentCall?.Dispose(); StreamClosed?.Invoke(this, new StreamClosedEventArgs()); }
public void Dispose() { _holdingLineRequest?.Dispose(); _channel?.ShutdownAsync().Wait(TimeSpan.FromSeconds(5)); _channel?.Dispose(); StartStreamCallback = default; StopStreamCallback = default; CloseApplicationCallback = default; }
/// <summary> /// 使用しているリソースを解放します。 /// </summary> /// <param name="disposing">dispose メソッドから呼び出されたかどうか</param> protected override void Dispose(bool disposing) { try { if (m_DisposableCall) { m_Call.Dispose(); } } finally { base.Dispose(disposing); } }
public void Shutdown() { if (_invoiceStream != null) { _invoiceStream.Dispose(); } if (_graphStream != null) { _graphStream.Dispose(); } if (_transactionStream != null) { _transactionStream.Dispose(); } rpcChannel.ShutdownAsync().Wait(); }
Action <bool> onNextFn(AsyncServerStreamingCall <Example.HelloReply> call) { return(ok => { if (ok) { replyCount++; Example.HelloReply helloReply = call.ResponseStream.Current; Debug.Log("Got " + replyCount.ToString() + " greeting, I think: " + helloReply.Message); call.ResponseStream.MoveNext().StartAsCoroutine <bool>(this.onNextFn(call)); } else { Debug.Log("End of stream or failure. Status: " + call.GetStatus() + ". Retrying!"); call.Dispose(); } }); }
public async Task Subscribe() { try { call = Client.SubscribeForMessages(new SubscribtionRequest() { }); while (await call.ResponseStream.MoveNext()) { Message mess = call.ResponseStream.Current; commonWriter.PutData(mess); //Console.WriteLine(string.Format("New Message! " + // "ChatId: {0}; MessageId: {1}; Text: {2};", mess.ChatId, mess.Id, mess.Text)); } } catch (Grpc.Core.RpcException ex) { call.Dispose(); } }
public void Dispose() { subscriptionThread?.Abort(); subscriptionThread = null; if (subscriptionListener != null) { subscriptionListener.ServerEventReceived -= _eventHandler.Invoke; subscriptionListener.Dispose(); subscriptionListener = null; } subscription?.Dispose(); subscription = null; workingTaskCancellationTokenSource?.Cancel(); workingTaskCancellationTokenSource?.Dispose(); workingTaskCancellationTokenSource = null; isListening = false; }
private async Task TryRecoverOnFailureAsync(CancellationToken cancellationToken, Exception exception) { _currentCall?.Dispose(); _currentCall = null; //reconnect on failure which will call reliableconnect and respect resumetoken and resumeskip cancellationToken.ThrowIfCancellationRequested(); Logger.Warn( () => $"An error occurred attemping to iterate through the sql query. Attempting to recover. Exception:{exception}"); //when we reconnect, we purposely do not do a *reliable*movenext. If we fail to fast forward on the reconnect //we bail out completely and surface the error. _isReading = await ReliableConnectAsync(cancellationToken).ConfigureAwait(false); if (_isReading) { // we try one more time to advance. Note that we should have done an exponential backoff retry // on the initial connect -- but MoveNext is not idempotent, so all we can do if it fails is start // from scratch. But in case something is going horribly awry, we don't want to spin indefinitely, // so we bail if the recovery isn't successful in moving to the next item. try { _isReading = await _currentCall.ResponseStream.MoveNext(cancellationToken) .WithSessionChecking(() => _session).ConfigureAwait(false); _resumeSkipCount++; } catch (Exception e) { Logger.Warn(() => $"An error occurred attemping to recover. Exception:{e}"); //At this point, we give up, rethrowing and setting state such that it will //need to reconnect if the user calls MoveNext again. _currentCall?.Dispose(); _currentCall = null; throw; } } }
// StartServerStream starts a background task listening to server responses // https://github.com/grpc/grpc/issues/21734#issuecomment-578519701 private async Task <AsyncServerStreamingCall <GameData> > StartServerStream() { try { while (await _stream.ResponseStream.MoveNext()) { _tokenSource.Token.ThrowIfCancellationRequested(); GameData gd = _stream.ResponseStream.Current; game.Set(gd); game.PlayerRealPosition = gd.Player.Position; // Debug.Log($"> {gd}"); AckIfNeeded(gd.Info.AckToken); } } catch (RpcException ex) when(ex.StatusCode == StatusCode.Cancelled) { _mGameFailedEvent.Invoke($"Stream cancelled: {ex}"); } catch (OperationCanceledException ex) { _mGameFailedEvent.Invoke($"server streaming thread cancelled: {ex}"); _stream.Dispose(); } catch (RpcException ex) { _mGameFailedEvent.Invoke(ex.ToString()); } catch (Exception ex) { _mGameFailedEvent.Invoke($"Server reading thread failed: {ex}"); Application.Quit(); } Debug.Log("Exiting server info thread..."); return(null); }
/// <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 AsyncServerStreamingCall <TResponse> Regist <TRequest, TResponse>(AsyncServerStreamingCall <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); AsyncServerStreamingCall <TResponse> wrap = new AsyncServerStreamingCall <TResponse>( new ResponseStreamReader <TResponse>(call.ResponseStream, method, host, options, state.OnEndResponse, performanceListener) , call.ResponseHeadersAsync , call.GetStatus , call.GetTrailers , releaser.Dispose ); releaser.Target = wrap; GrpcCallInvokerContext.AddState(wrap, state); return(wrap); }
public void Dispose() { _call.Dispose(); }
public void Dispose() { m_Call.Dispose(); }
public void Dispose() { _cancelSource.Cancel(); _streamingCall?.Dispose(); }
protected new void OnDestroy() { this.RunCatching(_ => looper.Dispose()); this.RunCatching(_ => call.Dispose()); base.OnDestroy(); }