internal static ReadFeedResponse <TInput> CreateResponse <TInput>(
ResponseMessage responseMessage,
CosmosSerializerCore serializerCore,
Documents.ResourceType resourceType)
{
using (responseMessage)
{
responseMessage.EnsureSuccessStatusCode();
CosmosArray cosmosArray = null;
if (responseMessage.Content != null)
{
cosmosArray = CosmosElementSerializer.ToCosmosElements(
responseMessage.Content,
resourceType,
null);
}
ReadFeedResponse <TInput> readFeedResponse = new ReadFeedResponse <TInput>(
httpStatusCode: responseMessage.StatusCode,
cosmosArray: cosmosArray,
serializerCore: serializerCore,
responseMessageHeaders: responseMessage.Headers,
diagnostics: responseMessage.Diagnostics);
return(readFeedResponse);
}
}
private QueryResponse(
IEnumerable <CosmosElement> result,
int count,
long responseLengthBytes,
CosmosQueryResponseMessageHeaders responseHeaders,
IReadOnlyDictionary <string, QueryMetrics> queryMetrics,
HttpStatusCode statusCode,
RequestMessage requestMessage,
string errorMessage,
Error error)
: base(
statusCode: statusCode,
requestMessage: requestMessage,
errorMessage: errorMessage,
error: error,
headers: responseHeaders)
{
this.CosmosElements = result;
this.Count = count;
this.ResponseLengthBytes = responseLengthBytes;
this.queryMetrics = queryMetrics;
this.memoryStream = new Lazy <MemoryStream>(() => CosmosElementSerializer.ToStream(
this.QueryHeaders.ContainerRid,
this.CosmosElements,
this.QueryHeaders.ResourceType,
this.CosmosSerializationOptions));
}
private async Task <ResponseMessage> ReadNextInternalAsync(
CosmosDiagnosticsContext diagnostics,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
Stream stream = null;
OperationType operation = OperationType.ReadFeed;
if (this.querySpec != null)
{
stream = this.clientContext.SerializerCore.ToStreamSqlQuerySpec(this.querySpec, this.resourceType);
operation = OperationType.Query;
}
ResponseMessage responseMessage = await this.clientContext.ProcessResourceOperationStreamAsync(
resourceUri : this.containerCore.LinkUri,
resourceType : this.resourceType,
operationType : operation,
requestOptions : this.queryRequestOptions,
cosmosContainerCore : this.containerCore,
partitionKey : this.queryRequestOptions?.PartitionKey,
streamPayload : stream,
requestEnricher : request =>
{
FeedRangeVisitor feedRangeVisitor = new FeedRangeVisitor(request);
this.FeedRangeInternal.Accept(feedRangeVisitor);
this.FeedRangeContinuation.Accept(feedRangeVisitor, QueryRequestOptions.FillContinuationToken);
if (this.querySpec != null)
{
request.Headers.Add(HttpConstants.HttpHeaders.ContentType, MediaTypes.QueryJson);
request.Headers.Add(HttpConstants.HttpHeaders.IsQuery, bool.TrueString);
}
},
diagnosticsContext : diagnostics,
cancellationToken : cancellationToken);
ShouldRetryResult shouldRetryOnSplit = await this.FeedRangeContinuation.HandleSplitAsync(this.containerCore, responseMessage, cancellationToken);
if (shouldRetryOnSplit.ShouldRetry)
{
return(await this.ReadNextInternalAsync(diagnostics, cancellationToken));
}
if (responseMessage.Content != null)
{
await CosmosElementSerializer.RewriteStreamAsTextAsync(responseMessage, this.queryRequestOptions);
}
if (responseMessage.IsSuccessStatusCode)
{
this.FeedRangeContinuation.ReplaceContinuation(responseMessage.Headers.ContinuationToken);
this.hasMoreResultsInternal = !this.FeedRangeContinuation.IsDone;
return(FeedRangeResponse.CreateSuccess(responseMessage, this.FeedRangeContinuation));
}
else
{
this.hasMoreResultsInternal = false;
return(FeedRangeResponse.CreateFailure(responseMessage));
}
}
internal static ReadFeedResponse <TInput> CreateResponse <TInput>(
ResponseMessage responseMessage,
CosmosSerializerCore serializerCore,
Documents.ResourceType resourceType)
{
using (responseMessage)
{
// ReadFeed can return 304 on some scenarios (Change Feed for example)
if (responseMessage.StatusCode != HttpStatusCode.NotModified)
{
responseMessage.EnsureSuccessStatusCode();
}
CosmosArray cosmosArray = null;
if (responseMessage.Content != null)
{
cosmosArray = CosmosElementSerializer.ToCosmosElements(
responseMessage.Content,
resourceType,
null);
}
ReadFeedResponse <TInput> readFeedResponse = new ReadFeedResponse <TInput>(
httpStatusCode: responseMessage.StatusCode,
cosmosArray: cosmosArray,
serializerCore: serializerCore,
responseMessageHeaders: responseMessage.Headers,
diagnostics: responseMessage.Diagnostics);
return(readFeedResponse);
}
}
private QueryResponseCore GetCosmosElementResponse(
QueryRequestOptions requestOptions,
ResourceType resourceType,
ResponseMessage cosmosResponseMessage,
PartitionKeyRangeIdentity partitionKeyRangeIdentity,
SchedulingStopwatch schedulingStopwatch)
{
using (cosmosResponseMessage)
{
QueryPageDiagnostics diagnostics = new QueryPageDiagnostics(
partitionKeyRangeId: partitionKeyRangeIdentity.PartitionKeyRangeId,
queryMetricText: cosmosResponseMessage.Headers.QueryMetricsText,
indexUtilizationText: cosmosResponseMessage.Headers[HttpConstants.HttpHeaders.IndexUtilization],
requestDiagnostics: cosmosResponseMessage.Diagnostics,
schedulingStopwatch: schedulingStopwatch);
IReadOnlyCollection <QueryPageDiagnostics> pageDiagnostics = new List <QueryPageDiagnostics>()
{
diagnostics
};
if (!cosmosResponseMessage.IsSuccessStatusCode)
{
return(QueryResponseCore.CreateFailure(
statusCode: cosmosResponseMessage.StatusCode,
subStatusCodes: cosmosResponseMessage.Headers.SubStatusCode,
errorMessage: cosmosResponseMessage.ErrorMessage,
requestCharge: cosmosResponseMessage.Headers.RequestCharge,
activityId: cosmosResponseMessage.Headers.ActivityId,
diagnostics: pageDiagnostics));
}
MemoryStream memoryStream = cosmosResponseMessage.Content as MemoryStream;
if (memoryStream == null)
{
memoryStream = new MemoryStream();
cosmosResponseMessage.Content.CopyTo(memoryStream);
}
long responseLengthBytes = memoryStream.Length;
CosmosArray cosmosArray = CosmosElementSerializer.ToCosmosElements(
memoryStream,
resourceType,
requestOptions.CosmosSerializationFormatOptions);
int itemCount = cosmosArray.Count;
return(QueryResponseCore.CreateSuccess(
result: cosmosArray,
requestCharge: cosmosResponseMessage.Headers.RequestCharge,
activityId: cosmosResponseMessage.Headers.ActivityId,
diagnostics: pageDiagnostics,
responseLengthBytes: cosmosResponseMessage.Headers.ContentLengthAsLong,
disallowContinuationTokenMessage: null,
continuationToken: cosmosResponseMessage.Headers.ContinuationToken));
}
}
internal IEnumerable <T> FromFeedResponseStream <T>(
Stream stream,
ResourceType resourceType)
{
CosmosArray cosmosArray = CosmosElementSerializer.ToCosmosElements(
stream,
resourceType);
return(CosmosElementSerializer.GetResources <T>(
cosmosArray: cosmosArray,
serializerCore: this));
}
private async Task <ResponseMessage> ReadNextInternalAsync(
ITrace trace,
CosmosDiagnosticsContext diagnostics,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
if (trace == null)
{
throw new ArgumentNullException(nameof(trace));
}
Stream stream = null;
OperationType operation = OperationType.ReadFeed;
if (this.querySpec != null)
{
stream = this.clientContext.SerializerCore.ToStreamSqlQuerySpec(this.querySpec, this.resourceType);
operation = OperationType.Query;
}
ResponseMessage responseMessage = await this.clientContext.ProcessResourceOperationStreamAsync(
resourceUri : this.resourceLink,
resourceType : this.resourceType,
operationType : operation,
requestOptions : this.requestOptions,
cosmosContainerCore : null,
feedRange : this.requestOptions?.PartitionKey.HasValue ?? false?new FeedRangePartitionKey(this.requestOptions.PartitionKey.Value) : null,
streamPayload : stream,
requestEnricher : request =>
{
QueryRequestOptions.FillContinuationToken(request, this.ContinuationToken);
if (this.querySpec != null)
{
request.Headers.Add(HttpConstants.HttpHeaders.ContentType, MediaTypes.QueryJson);
request.Headers.Add(HttpConstants.HttpHeaders.IsQuery, bool.TrueString);
}
},
diagnosticsContext : diagnostics,
trace : trace,
cancellationToken : cancellationToken);
this.ContinuationToken = responseMessage.Headers.ContinuationToken;
this.hasMoreResultsInternal = this.ContinuationToken != null && responseMessage.StatusCode != HttpStatusCode.NotModified;
if (responseMessage.Content != null)
{
await CosmosElementSerializer.RewriteStreamAsTextAsync(responseMessage, this.requestOptions);
}
return(responseMessage);
}
private QueryResponseCore GetCosmosElementResponse(
Guid clientQueryCorrelationId,
QueryRequestOptions requestOptions,
ResourceType resourceType,
ResponseMessage cosmosResponseMessage,
PartitionKeyRangeIdentity partitionKeyRangeIdentity,
Action <QueryPageDiagnostics> queryPageDiagnostics)
{
using (cosmosResponseMessage)
{
QueryPageDiagnostics queryPage = new QueryPageDiagnostics(
clientQueryCorrelationId: clientQueryCorrelationId,
partitionKeyRangeId: partitionKeyRangeIdentity.PartitionKeyRangeId,
queryMetricText: cosmosResponseMessage.Headers.QueryMetricsText,
indexUtilizationText: cosmosResponseMessage.Headers[HttpConstants.HttpHeaders.IndexUtilization],
diagnosticsContext: cosmosResponseMessage.DiagnosticsContext);
queryPageDiagnostics(queryPage);
if (!cosmosResponseMessage.IsSuccessStatusCode)
{
return(QueryResponseCore.CreateFailure(
statusCode: cosmosResponseMessage.StatusCode,
subStatusCodes: cosmosResponseMessage.Headers.SubStatusCode,
cosmosException: cosmosResponseMessage.CosmosException,
requestCharge: cosmosResponseMessage.Headers.RequestCharge,
activityId: cosmosResponseMessage.Headers.ActivityId));
}
if (!(cosmosResponseMessage.Content is MemoryStream memoryStream))
{
memoryStream = new MemoryStream();
cosmosResponseMessage.Content.CopyTo(memoryStream);
}
long responseLengthBytes = memoryStream.Length;
CosmosArray cosmosArray = CosmosElementSerializer.ToCosmosElements(
memoryStream,
resourceType,
requestOptions.CosmosSerializationFormatOptions);
int itemCount = cosmosArray.Count;
return(QueryResponseCore.CreateSuccess(
result: cosmosArray,
requestCharge: cosmosResponseMessage.Headers.RequestCharge,
activityId: cosmosResponseMessage.Headers.ActivityId,
responseLengthBytes: responseLengthBytes,
disallowContinuationTokenMessage: null,
continuationToken: cosmosResponseMessage.Headers.ContinuationToken));
}
}
protected ReadFeedResponse(
HttpStatusCode httpStatusCode,
CosmosArray cosmosArray,
CosmosSerializerCore serializerCore,
Headers responseMessageHeaders,
CosmosDiagnostics diagnostics)
{
this.Count = cosmosArray.Count;
this.Headers = responseMessageHeaders;
this.StatusCode = httpStatusCode;
this.Diagnostics = diagnostics;
this.Resource = CosmosElementSerializer.GetResources <T>(
cosmosArray: cosmosArray,
serializerCore: serializerCore);
}
private async Task<ResponseMessage> ReadNextInternalAsync(
CosmosDiagnosticsContext diagnostics,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ResponseMessage responseMessage = await this.clientContext.ProcessResourceOperationStreamAsync(
resourceUri: this.containerCore.LinkUri,
resourceType: ResourceType.Document,
operationType: OperationType.ReadFeed,
requestOptions: this.queryRequestOptions,
cosmosContainerCore: this.containerCore,
partitionKey: this.queryRequestOptions?.PartitionKey,
streamPayload: null,
requestEnricher: request =>
{
FeedRangeVisitor feedRangeVisitor = new FeedRangeVisitor(request);
this.FeedRangeInternal.Accept(feedRangeVisitor);
this.FeedRangeContinuation.Accept(feedRangeVisitor, QueryRequestOptions.FillContinuationToken);
},
diagnosticsContext: diagnostics,
cancellationToken: cancellationToken);
ShouldRetryResult shouldRetryOnSplit = await this.FeedRangeContinuation.HandleSplitAsync(this.containerCore, responseMessage, cancellationToken);
if (shouldRetryOnSplit.ShouldRetry)
{
return await this.ReadNextInternalAsync(diagnostics, cancellationToken);
}
if (responseMessage.Content != null)
{
await CosmosElementSerializer.RewriteStreamAsTextAsync(responseMessage, this.queryRequestOptions);
}
if (responseMessage.IsSuccessStatusCode)
{
this.FeedRangeContinuation.ReplaceContinuation(responseMessage.Headers.ContinuationToken);
this.hasMoreResultsInternal = !this.FeedRangeContinuation.IsDone;
return FeedRangeResponse.CreateSuccess(responseMessage, this.FeedRangeContinuation);
}
else
{
this.hasMoreResultsInternal = false;
return FeedRangeResponse.CreateFailure(responseMessage);
}
}
private QueryResponseCore GetCosmosElementResponse(
QueryRequestOptions requestOptions,
ResourceType resourceType,
ResponseMessage cosmosResponseMessage)
{
using (cosmosResponseMessage)
{
if (!cosmosResponseMessage.IsSuccessStatusCode)
{
return(QueryResponseCore.CreateFailure(
statusCode: cosmosResponseMessage.StatusCode,
subStatusCodes: cosmosResponseMessage.Headers.SubStatusCode,
errorMessage: cosmosResponseMessage.ErrorMessage,
requestCharge: cosmosResponseMessage.Headers.RequestCharge,
activityId: cosmosResponseMessage.Headers.ActivityId,
queryMetricsText: cosmosResponseMessage.Headers.QueryMetricsText,
queryMetrics: null));
}
MemoryStream memoryStream = cosmosResponseMessage.Content as MemoryStream;
if (memoryStream == null)
{
memoryStream = new MemoryStream();
cosmosResponseMessage.Content.CopyTo(memoryStream);
}
long responseLengthBytes = memoryStream.Length;
CosmosArray cosmosArray = CosmosElementSerializer.ToCosmosElements(
memoryStream,
resourceType,
requestOptions.CosmosSerializationFormatOptions);
int itemCount = cosmosArray.Count;
return(QueryResponseCore.CreateSuccess(
result: cosmosArray,
requestCharge: cosmosResponseMessage.Headers.RequestCharge,
activityId: cosmosResponseMessage.Headers.ActivityId,
queryMetricsText: cosmosResponseMessage.Headers.QueryMetricsText,
queryMetrics: null,
requestStatistics: null,
responseLengthBytes: cosmosResponseMessage.Headers.ContentLengthAsLong,
disallowContinuationTokenMessage: null,
continuationToken: cosmosResponseMessage.Headers.ContinuationToken));
}
}
public void CosmosElementsToFindArrayWithSerialization()
{
using (MemoryStream ms = new MemoryStream(this.payloadBytes))
{
CosmosArray array = CosmosElementSerializer.ToCosmosElements(
ms,
Documents.ResourceType.Document,
null);
IReadOnlyList <ToDoActivity> results = CosmosElementSerializer.GetResources <ToDoActivity>(
array,
this.serializerCore);
if (results.Count != 1000)
{
throw new Exception();
}
}
}
public void CosmosElementsToFindArray()
{
using (MemoryStream ms = new MemoryStream(this.payloadBytes))
{
CosmosArray array = CosmosElementSerializer.ToCosmosElements(
ms,
Documents.ResourceType.Document,
null);
using (MemoryStream memoryStream = CosmosElementSerializer.ElementsToMemoryStream(
array,
null))
{
if (ms.Length == memoryStream.Length)
{
throw new Exception();
}
}
}
}
private QueryResponse GetCosmosElementResponse(
QueryRequestOptions requestOptions,
ResourceType resourceType,
string containerResourceId,
ResponseMessage cosmosResponseMessage)
{
using (cosmosResponseMessage)
{
if (!cosmosResponseMessage.IsSuccessStatusCode)
{
return(QueryResponse.CreateFailure(
CosmosQueryResponseMessageHeaders.ConvertToQueryHeaders(cosmosResponseMessage.Headers, resourceType, containerResourceId),
cosmosResponseMessage.StatusCode,
cosmosResponseMessage.RequestMessage,
cosmosResponseMessage.ErrorMessage,
cosmosResponseMessage.Error));
}
MemoryStream memoryStream = cosmosResponseMessage.Content as MemoryStream;
if (memoryStream == null)
{
memoryStream = new MemoryStream();
cosmosResponseMessage.Content.CopyTo(memoryStream);
}
long responseLengthBytes = memoryStream.Length;
CosmosArray cosmosArray = CosmosElementSerializer.ToCosmosElements(
memoryStream,
resourceType,
requestOptions.CosmosSerializationOptions);
int itemCount = cosmosArray.Count;
return(QueryResponse.CreateSuccess(
result: cosmosArray,
count: itemCount,
responseHeaders: CosmosQueryResponseMessageHeaders.ConvertToQueryHeaders(cosmosResponseMessage.Headers, resourceType, containerResourceId),
responseLengthBytes: responseLengthBytes));
}
}
internal static QueryResponse CreateSuccess(
IReadOnlyList <CosmosElement> result,
int count,
long responseLengthBytes,
CosmosQueryResponseMessageHeaders responseHeaders,
CosmosDiagnosticsContext diagnostics,
CosmosSerializationFormatOptions serializationOptions)
{
if (count < 0)
{
throw new ArgumentOutOfRangeException("count must be positive");
}
if (responseLengthBytes < 0)
{
throw new ArgumentOutOfRangeException("responseLengthBytes must be positive");
}
Lazy <MemoryStream> memoryStream = new Lazy <MemoryStream>(() => CosmosElementSerializer.ToStream(
responseHeaders.ContainerRid,
result,
responseHeaders.ResourceType,
serializationOptions));
QueryResponse cosmosQueryResponse = new QueryResponse(
result: result,
count: count,
responseLengthBytes: responseLengthBytes,
responseHeaders: responseHeaders,
diagnostics: diagnostics,
statusCode: HttpStatusCode.OK,
errorMessage: null,
error: null,
requestMessage: null,
memoryStream: memoryStream,
serializationOptions: serializationOptions);
return(cosmosQueryResponse);
}
