public override async ValueTask <bool> MoveNextAsync()
{
this.cancellationToken.ThrowIfCancellationRequested();
try
{
if (!await this.inputStage.MoveNextAsync())
{
this.Current = default;
return(false);
}
this.Current = this.inputStage.Current;
return(true);
}
catch (OperationCanceledException) when(this.cancellationToken.IsCancellationRequested)
{
// Per cancellationToken.ThrowIfCancellationRequested(); line above, this function should still throw OperationCanceledException.
throw;
}
catch (Exception ex)
{
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(ex);
this.Current = TryCatch <QueryPage> .FromException(cosmosException);
return(true);
}
}
public override async Task <ResponseMessage> ReadNextAsync(CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
TryCatch <CrossPartitionChangeFeedAsyncEnumerator> monadicEnumerator = await this.lazyMonadicEnumerator.GetValueAsync(cancellationToken);
if (monadicEnumerator.Failed)
{
Exception createException = monadicEnumerator.Exception;
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(createException);
return(new ResponseMessage(
cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
diagnostics: new CosmosDiagnosticsContextCore()));
}
CrossPartitionChangeFeedAsyncEnumerator enumerator = monadicEnumerator.Result;
if (!await enumerator.MoveNextAsync())
{
throw new InvalidOperationException("ChangeFeed enumerator should always have a next continuation");
}
if (enumerator.Current.Failed)
{
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(enumerator.Current.Exception);
if (!IsRetriableException(cosmosException))
{
this.hasMoreResults = false;
}
return(new ResponseMessage(
cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
diagnostics: new CosmosDiagnosticsContextCore()));
}
CrossFeedRangePage <Pagination.ChangeFeedPage, ChangeFeedState> crossFeedRangePage = enumerator.Current.Result;
Pagination.ChangeFeedPage changeFeedPage = crossFeedRangePage.Page;
ResponseMessage responseMessage;
if (changeFeedPage is Pagination.ChangeFeedSuccessPage changeFeedSuccessPage)
{
responseMessage = new ResponseMessage(statusCode: System.Net.HttpStatusCode.OK)
{
Content = changeFeedSuccessPage.Content
};
}
else
{
responseMessage = new ResponseMessage(statusCode: System.Net.HttpStatusCode.NotModified);
}
CrossFeedRangeState <ChangeFeedState> crossFeedRangeState = crossFeedRangePage.State;
string continuationToken;
if (this.changeFeedRequestOptions.EmitOldContinuationToken)
{
List <CompositeContinuationToken> compositeContinuationTokens = new List <CompositeContinuationToken>();
for (int i = 0; i < crossFeedRangeState.Value.Length; i++)
{
FeedRangeState <ChangeFeedState> changeFeedFeedRangeState = crossFeedRangeState.Value.Span[i];
string token = changeFeedFeedRangeState.State is ChangeFeedStateContinuation changeFeedStateContinuation ? ((CosmosString)changeFeedStateContinuation.ContinuationToken).Value : null;
Documents.Routing.Range <string> range = ((FeedRangeEpk)changeFeedFeedRangeState.FeedRange).Range;
CompositeContinuationToken compositeContinuationToken = new CompositeContinuationToken()
{
Range = range,
Token = token,
};
compositeContinuationTokens.Add(compositeContinuationToken);
}
FeedRangeCompositeContinuation feedRangeCompositeContinuationToken = new FeedRangeCompositeContinuation(
await this.documentContainer.GetResourceIdentifierAsync(cancellationToken),
FeedRangeEpk.FullRange,
compositeContinuationTokens);
continuationToken = feedRangeCompositeContinuationToken.ToString();
}
else
{
ChangeFeedCrossFeedRangeState changeFeedCrossFeedRangeState = new ChangeFeedCrossFeedRangeState(crossFeedRangeState.Value);
continuationToken = VersionedAndRidCheckedCompositeToken.ToCosmosElement(
new VersionedAndRidCheckedCompositeToken(
VersionedAndRidCheckedCompositeToken.Version.V2,
changeFeedCrossFeedRangeState.ToCosmosElement(),
await this.documentContainer.GetResourceIdentifierAsync(cancellationToken))).ToString();
}
responseMessage.Headers.ContinuationToken = continuationToken;
responseMessage.Headers.RequestCharge = changeFeedPage.RequestCharge;
responseMessage.Headers.ActivityId = changeFeedPage.ActivityId;
return(responseMessage);
}
public override async Task <ResponseMessage> ReadNextAsync(
ITrace trace,
CancellationToken cancellationToken = default)
{
if (trace == null)
{
throw new ArgumentNullException(nameof(trace));
}
cancellationToken.ThrowIfCancellationRequested();
if (!this.hasMoreResults)
{
throw new InvalidOperationException("Should not be calling FeedIterator that does not have any more results");
}
if (this.monadicEnumerator.Failed)
{
this.hasMoreResults = false;
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(this.monadicEnumerator.Exception);
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.BadRequest,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
trace: trace));
}
CrossPartitionReadFeedAsyncEnumerator enumerator = this.monadicEnumerator.Result;
TryCatch <CrossFeedRangePage <Pagination.ReadFeedPage, ReadFeedState> > monadicPage;
try
{
if (!await enumerator.MoveNextAsync(trace))
{
throw new InvalidOperationException("Should not be calling enumerator that does not have any more results");
}
monadicPage = enumerator.Current;
}
catch (Exception ex)
{
monadicPage = TryCatch <CrossFeedRangePage <Pagination.ReadFeedPage, ReadFeedState> > .FromException(ex);
}
if (monadicPage.Failed)
{
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(monadicPage.Exception);
if (!IsRetriableException(cosmosException))
{
this.hasMoreResults = false;
}
return(new ResponseMessage(
statusCode: cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
trace: trace));
}
CrossFeedRangePage <Pagination.ReadFeedPage, ReadFeedState> crossFeedRangePage = monadicPage.Result;
if (crossFeedRangePage.State == default)
{
this.hasMoreResults = false;
}
// Make the continuation token match the older format:
string continuationToken;
if (crossFeedRangePage.State != null)
{
List <CompositeContinuationToken> compositeContinuationTokens = new List <CompositeContinuationToken>();
CrossFeedRangeState <ReadFeedState> crossFeedRangeState = crossFeedRangePage.State;
for (int i = 0; i < crossFeedRangeState.Value.Length; i++)
{
FeedRangeState <ReadFeedState> feedRangeState = crossFeedRangeState.Value.Span[i];
FeedRangeEpk feedRange;
if (feedRangeState.FeedRange is FeedRangeEpk feedRangeEpk)
{
feedRange = feedRangeEpk;
}
else
{
feedRange = FeedRangeEpk.FullRange;
}
ReadFeedState readFeedState = feedRangeState.State;
CompositeContinuationToken compositeContinuationToken = new CompositeContinuationToken()
{
Range = feedRange.Range,
Token = readFeedState is ReadFeedBeginningState ? null : ((ReadFeedContinuationState)readFeedState).ContinuationToken.ToString(),
};
compositeContinuationTokens.Add(compositeContinuationToken);
}
FeedRangeInternal outerFeedRange;
if ((this.queryRequestOptions != null) && this.queryRequestOptions.PartitionKey.HasValue)
{
outerFeedRange = new FeedRangePartitionKey(this.queryRequestOptions.PartitionKey.Value);
}
else if ((this.queryRequestOptions != null) && (this.queryRequestOptions.FeedRange != null))
{
outerFeedRange = (FeedRangeInternal)this.queryRequestOptions.FeedRange;
}
else
{
outerFeedRange = FeedRangeEpk.FullRange;
}
FeedRangeCompositeContinuation feedRangeCompositeContinuation = new FeedRangeCompositeContinuation(
containerRid: string.Empty,
feedRange: outerFeedRange,
compositeContinuationTokens);
continuationToken = feedRangeCompositeContinuation.ToString();
}
else
{
continuationToken = null;
}
Pagination.ReadFeedPage page = crossFeedRangePage.Page;
Headers headers = new Headers()
{
RequestCharge = page.RequestCharge,
ActivityId = page.ActivityId,
ContinuationToken = continuationToken,
};
foreach (KeyValuePair <string, string> kvp in page.AdditionalHeaders)
{
headers[kvp.Key] = kvp.Value;
}
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.OK,
requestMessage: default,
/// <summary>
/// Get the next set of results from the cosmos service
/// </summary>
/// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>A query response from cosmos service</returns>
public override async Task <ResponseMessage> ReadNextAsync(CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
if (!this.hasMoreResults)
{
throw new InvalidOperationException("Should not be calling FeedIterator that does not have any more results");
}
if (this.monadicEnumerator.Failed)
{
this.hasMoreResults = false;
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(this.monadicEnumerator.Exception);
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.BadRequest,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
diagnostics: cosmosException.DiagnosticsContext));
}
CrossPartitionReadFeedAsyncEnumerator enumerator = this.monadicEnumerator.Result;
TryCatch <ReadFeedPage> monadicPage;
try
{
if (!await enumerator.MoveNextAsync())
{
throw new InvalidOperationException("Should not be calling enumerator that does not have any more results");
}
monadicPage = enumerator.Current;
}
catch (Exception ex)
{
monadicPage = TryCatch <ReadFeedPage> .FromException(ex);
}
if (monadicPage.Failed)
{
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(monadicPage.Exception);
if (!IsRetriableException(cosmosException))
{
this.hasMoreResults = false;
}
return(new ResponseMessage(
statusCode: cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
diagnostics: cosmosException.DiagnosticsContext));
}
ReadFeedPage readFeedPage = monadicPage.Result;
if (readFeedPage.State == default)
{
this.hasMoreResults = false;
}
// Make the continuation token match the older format:
string continuationToken;
if (readFeedPage.State != null)
{
List <CompositeContinuationToken> compositeContinuationTokens = new List <CompositeContinuationToken>();
CosmosArray compositeContinuationTokensCosmosArray = (CosmosArray)readFeedPage.State.ContinuationToken;
foreach (CosmosElement arrayItem in compositeContinuationTokensCosmosArray)
{
ReadFeedContinuationToken readFeedContinuationToken = ReadFeedContinuationToken.MonadicConvertFromCosmosElement(arrayItem).Result;
FeedRangeEpk feedRangeEpk = (FeedRangeEpk)readFeedContinuationToken.Range;
ReadFeedState readFeedState = readFeedContinuationToken.State;
CompositeContinuationToken compositeContinuationToken = new CompositeContinuationToken()
{
Range = feedRangeEpk.Range,
Token = readFeedState.ContinuationToken.ToString(),
};
compositeContinuationTokens.Add(compositeContinuationToken);
}
FeedRangeCompositeContinuation feedRangeCompositeContinuation = new FeedRangeCompositeContinuation(
containerRid: string.Empty,
feedRange: FeedRangeEpk.FullRange,
compositeContinuationTokens);
continuationToken = feedRangeCompositeContinuation.ToString();
}
else
{
continuationToken = null;
}
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.OK,
requestMessage: default,