public void WithCancellationToken() { CancellationToken token1 = new CancellationTokenSource().Token; var original = new CallSettings(token1, Expiration.None, null, null, null, null); CancellationToken token2 = new CancellationTokenSource().Token; var result = original.WithCancellationToken(token2); Assert.Same(Expiration.None, result.Expiration); Assert.Equal(token2, result.CancellationToken); }
public void WithCancellationToken() { CancellationToken token1 = new CancellationTokenSource().Token; CallTiming timing = CallTiming.FromExpiration(Expiration.None); var original = new CallSettings(token1, null, timing, null, null, null); CancellationToken token2 = new CancellationTokenSource().Token; var result = original.WithCancellationToken(token2); Assert.Same(timing, result.Timing); Assert.Equal(token2, result.CancellationToken); }
public void WithCancellationToken() { CancellationToken token1 = new CancellationTokenSource().Token; CallTiming timing = CallTiming.FromExpiration(Expiration.None); var original = new CallSettings(token1, null, timing, null, null, null); CancellationToken token2 = new CancellationTokenSource().Token; var result = original.WithCancellationToken(token2); Assert.Same(timing, result.Timing); Assert.Equal(token2, result.CancellationToken); }
public async Task <bool> MoveNext(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (_finished) { return(false); } CallSettings effectiveCallSettings = _parent._callSettings; if (cancellationToken != default(CancellationToken)) { effectiveCallSettings = effectiveCallSettings.WithCancellationToken(cancellationToken); } var response = await _parent._apiCall.Async(_request, effectiveCallSettings).ConfigureAwait(false); _finished = !MoreResultsAvailable(response); ModifyRequest(_request, response); Current = response; return(true); }
/// <summary> /// Fetches document snapshots from the server, based on an optional transaction ID. /// </summary> /// <param name="documents">The document references to fetch. Must not be null, or contain null references.</param> /// <param name="transactionId">A transaction ID, or null to not include any transaction ID.</param> /// <param name="fieldMask">The field mask to use to restrict which fields are retrieved. May be null, in which /// case no field mask is applied, and the complete documents are retrieved.</param> /// <param name="cancellationToken">A cancellation token for the operation.</param> /// <returns>The document snapshots, in the order they are provided in the response. (This may not be the order of <paramref name="documents"/>.)</returns> internal async Task <IList <DocumentSnapshot> > GetDocumentSnapshotsAsync(IEnumerable <DocumentReference> documents, ByteString transactionId, FieldMask fieldMask, CancellationToken cancellationToken) { GaxPreconditions.CheckNotNull(documents, nameof(documents)); var request = new BatchGetDocumentsRequest { Database = RootPath, Documents = { documents.Select(ExtractPath) }, Mask = fieldMask?.ToProto() }; if (transactionId != null) { request.Transaction = transactionId; } var clock = Client.Settings.Clock ?? SystemClock.Instance; var scheduler = Client.Settings.Scheduler ?? SystemScheduler.Instance; var callSettings = _batchGetCallSettings.WithCancellationToken(cancellationToken); // This is the function that we'll retry. We can't use the built-in retry functionality, because it's not a unary gRPC call. // (We could potentially simulate a unary call, but it would be a little odd to do so.) // Note that we perform a "whole request" retry. In theory we could collect some documents, then see an error, and only // request the remaining documents. Given how rarely we retry anyway in practice, that's probably not worth doing. Func <BatchGetDocumentsRequest, CallSettings, Task <List <DocumentSnapshot> > > function = async(req, settings) => { var stream = Client.BatchGetDocuments(req, settings); using (var responseStream = stream.ResponseStream) { List <DocumentSnapshot> snapshots = new List <DocumentSnapshot>(); // Note: no need to worry about passing the cancellation token in here, as we've passed it into the overall call. // If the token is cancelled, the call will be aborted. while (await responseStream.MoveNext().ConfigureAwait(false)) { var response = responseStream.Current; var readTime = Timestamp.FromProto(response.ReadTime); switch (response.ResultCase) { case BatchGetDocumentsResponse.ResultOneofCase.Found: snapshots.Add(DocumentSnapshot.ForDocument(this, response.Found, readTime)); break; case BatchGetDocumentsResponse.ResultOneofCase.Missing: snapshots.Add(DocumentSnapshot.ForMissingDocument(this, response.Missing, readTime)); break; default: throw new InvalidOperationException($"Unknown response type: {response.ResultCase}"); } } return(snapshots); } }; var retryingTask = RetryHelper.Retry(function, request, callSettings, clock, scheduler); return(await retryingTask.ConfigureAwait(false)); string ExtractPath(DocumentReference documentReference) { GaxPreconditions.CheckArgument(documentReference != null, nameof(documents), "DocumentReference sequence must not contain null elements."); return(documentReference.Path); } }