internal override async Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
Uri resourceUri,
ResourceType resourceType,
OperationType operationType,
SqlQuerySpec sqlQuerySpec,
string supportedQueryFeatures,
CancellationToken cancellationToken)
{
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo;
using (ResponseMessage message = await this.clientContext.ProcessResourceOperationStreamAsync(
resourceUri: resourceUri,
resourceType: resourceType,
operationType: operationType,
requestOptions: null,
partitionKey: null,
cosmosContainerCore: this.cosmosContainerCore,
streamPayload: this.clientContext.SqlQuerySpecSerializer.ToStream(sqlQuerySpec),
requestEnricher: (requestMessage) =>
{
requestMessage.Headers.Add(HttpConstants.HttpHeaders.ContentType, RuntimeConstants.MediaTypes.QueryJson);
requestMessage.Headers.Add(HttpConstants.HttpHeaders.IsQueryPlanRequest, bool.TrueString);
requestMessage.Headers.Add(HttpConstants.HttpHeaders.SupportedQueryFeatures, supportedQueryFeatures);
requestMessage.Headers.Add(HttpConstants.HttpHeaders.QueryVersion, new Version(major: 1, minor: 0).ToString());
requestMessage.UseGatewayMode = true;
},
cancellationToken: cancellationToken))
{
// Syntax exception are argument exceptions and thrown to the user.
message.EnsureSuccessStatusCode();
partitionedQueryExecutionInfo = this.clientContext.CosmosSerializer.FromStream <PartitionedQueryExecutionInfo>(message.Content);
}
return(partitionedQueryExecutionInfo);
}
public void EnsureSuccessStatusCode_ThrowsOnFailure_ContainsJsonBody()
{
string message = "TestContent";
Error error = new Error();
error.Code = "code";
error.Message = message;
string testContent = JsonConvert.SerializeObject(error);
using (MemoryStream memoryStream = new MemoryStream())
{
StreamWriter sw = new StreamWriter(memoryStream);
sw.Write(testContent);
sw.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.NotFound)
{
Content = memoryStream
};
try
{
responseMessage.EnsureSuccessStatusCode();
Assert.Fail("Should have thrown");
}
catch (CosmosException exception)
{
Assert.IsTrue(exception.Message.Contains(message));
}
}
}
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);
}
}
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);
}
}
internal override async Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
Uri resourceUri,
ResourceType resourceType,
OperationType operationType,
SqlQuerySpec sqlQuerySpec,
Action <RequestMessage> requestEnricher,
CancellationToken cancellationToken)
{
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo;
using (ResponseMessage message = await this.clientContext.ProcessResourceOperationStreamAsync(
resourceUri: resourceUri,
resourceType: resourceType,
operationType: operationType,
requestOptions: null,
partitionKey: null,
cosmosContainerCore: this.cosmosContainerCore,
streamPayload: this.clientContext.CosmosSerializer.ToStream <SqlQuerySpec>(sqlQuerySpec),
requestEnricher: requestEnricher,
cancellationToken: cancellationToken))
{
// Syntax exception are argument exceptions and thrown to the user.
message.EnsureSuccessStatusCode();
partitionedQueryExecutionInfo = this.clientContext.CosmosSerializer.FromStream <PartitionedQueryExecutionInfo>(message.Content);
}
return(partitionedQueryExecutionInfo);
}
public void EnsureSuccessStatusCode_ThrowsOnFailure_ContainsBody()
{
string testContent = "TestContent";
using (MemoryStream memoryStream = new MemoryStream())
{
StreamWriter sw = new StreamWriter(memoryStream);
sw.Write(testContent);
sw.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.NotFound)
{
Content = memoryStream
};
try
{
responseMessage.EnsureSuccessStatusCode();
Assert.Fail("Should have thrown");
}
catch (CosmosException exception)
{
Assert.IsTrue(exception.Message.Contains(testContent));
}
}
}
internal static ReadFeedResponse <TInput> CreateResponse <TInput>(
ResponseMessage responseMessage,
CosmosSerializerCore serializerCore)
{
using (responseMessage)
{
// ReadFeed can return 304 on Change Feed responses
if (responseMessage.StatusCode != HttpStatusCode.NotModified)
{
responseMessage.EnsureSuccessStatusCode();
}
IReadOnlyCollection <TInput> resources = CosmosFeedResponseSerializer.FromFeedResponseStream <TInput>(
serializerCore,
responseMessage.Content);
ReadFeedResponse <TInput> readFeedResponse = new ReadFeedResponse <TInput>(
httpStatusCode: responseMessage.StatusCode,
resources: resources,
resourceCount: resources.Count,
responseMessageHeaders: responseMessage.Headers,
diagnostics: responseMessage.Diagnostics);
return(readFeedResponse);
}
}
public T ProcessMessage <T>(ResponseMessage responseMessage, Func <ResponseMessage, T> createResponse)
{
using (ResponseMessage message = responseMessage)
{
//Throw the exception
message.EnsureSuccessStatusCode();
return(createResponse(message));
}
}
internal async Task <T> ProcessMessageAsync <T>(Task <ResponseMessage> cosmosResponseTask, Func <ResponseMessage, T> createResponse)
{
using (ResponseMessage message = await cosmosResponseTask)
{
//Throw the exception
message.EnsureSuccessStatusCode();
return(createResponse(message));
}
}
internal T ToObjectInternal <T>(ResponseMessage cosmosResponseMessage, CosmosSerializer jsonSerializer)
{
//Throw the exception
cosmosResponseMessage.EnsureSuccessStatusCode();
if (cosmosResponseMessage.Content == null)
{
return(default(T));
}
return(jsonSerializer.FromStream <T>(cosmosResponseMessage.Content));
}
public T ProcessMessage <T>(ResponseMessage responseMessage, Func <ResponseMessage, T> createResponse)
{
using (ResponseMessage message = responseMessage)
{
//Throw the exception
message.EnsureSuccessStatusCode();
using (message.Trace.StartChild("Response Serialization"))
{
return(createResponse(message));
}
}
}
private async Task <ThroughputResponse> OfferRetryHelperForStaleRidCacheAsync(
Func <string, Task <ThroughputResponse> > executeOfferOperation,
CosmosDiagnosticsContext diagnosticsContext,
ITrace trace,
CancellationToken cancellationToken)
{
string rid = await this.GetCachedRIDAsync(
forceRefresh : false,
cancellationToken : cancellationToken);
ThroughputResponse throughputResponse = await executeOfferOperation(rid);
if (throughputResponse.StatusCode != HttpStatusCode.NotFound)
{
return(throughputResponse);
}
// Check if RID cache is stale
ResponseMessage responseMessage = await this.ReadContainerStreamAsync(
diagnosticsContext : diagnosticsContext,
requestOptions : null,
trace : trace,
cancellationToken : cancellationToken);
// Container does not exist
if (responseMessage.StatusCode == HttpStatusCode.NotFound)
{
return(new ThroughputResponse(
responseMessage.StatusCode,
responseMessage.Headers,
null,
diagnosticsContext.Diagnostics));
}
responseMessage.EnsureSuccessStatusCode();
ContainerProperties containerProperties = this.ClientContext.SerializerCore.FromStream <ContainerProperties>(responseMessage.Content);
// The RIDs match so return the original response.
if (string.Equals(rid, containerProperties.ResourceId))
{
return(throughputResponse);
}
// Get the offer with the new rid value
return(await executeOfferOperation(containerProperties.ResourceId));
}
public void EnsureSuccessStatusCode_ThrowsOnFailure_ContainsComplexJsonBody()
{
JObject error = new JObject
{
{ "Code", "code" },
{ "Message", "TestContent" },
{ "Error", new JArray {
"msg1", "msg2"
} },
{ "Link", "https://www.demolink.com" },
{ "Path", "/demo/path" },
{ "EscapedPath", @"/demo/path/with/escape/character" }
};
string testContent = JsonConvert.SerializeObject(error);
using (MemoryStream memoryStream = new MemoryStream())
{
StreamWriter sw = new StreamWriter(memoryStream);
sw.Write(testContent);
sw.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.NotFound)
{
Content = memoryStream
};
try
{
responseMessage.EnsureSuccessStatusCode();
Assert.Fail("Should have thrown");
}
catch (CosmosException exception)
{
Assert.IsTrue(exception.Message.Contains("code"));
Assert.IsTrue(exception.Message.Contains("TestContent"));
Assert.IsTrue(exception.Message.Contains("msg1"));
Assert.IsTrue(exception.Message.Contains("msg2"));
Assert.IsTrue(exception.Message.Contains("https://www.demolink.com"));
Assert.IsTrue(exception.Message.Contains("/demo/path"));
Assert.IsTrue(exception.Message.Contains("/demo/path/with/escape/character"));
Assert.IsFalse(exception.Message.Contains("}"));
Assert.IsFalse(exception.Message.Contains("{"));
}
}
}
internal FeedResponse <T> CreateQueryFeedResponse <T>(
ResponseMessage cosmosResponseMessage)
{
//Throw the exception
cosmosResponseMessage.EnsureSuccessStatusCode();
QueryResponse queryResponse = cosmosResponseMessage as QueryResponse;
if (queryResponse != null)
{
return(QueryResponse <T> .CreateResponse <T>(
responseMessage : queryResponse,
jsonSerializer : this.cosmosSerializer));
}
return(ReadFeedResponse <T> .CreateResponse <T>(
cosmosResponseMessage,
this.cosmosSerializer));
}
internal T ToObjectInternal <T>(ResponseMessage cosmosResponseMessage, CosmosSerializer jsonSerializer)
{
// Not finding something is part of a normal work-flow and should not be an exception.
// This prevents the unnecessary overhead of an exception
if (cosmosResponseMessage.StatusCode == HttpStatusCode.NotFound)
{
return(default(T));
}
//Throw the exception
cosmosResponseMessage.EnsureSuccessStatusCode();
if (cosmosResponseMessage.Content == null)
{
return(default(T));
}
return(jsonSerializer.FromStream <T>(cosmosResponseMessage.Content));
}
internal static ReadFeedResponse <TInput> CreateResponse <TInput>(
ResponseMessage responseMessage,
CosmosSerializerCore serializerCore)
{
using (responseMessage)
{
responseMessage.EnsureSuccessStatusCode();
IReadOnlyCollection <TInput> resources = CosmosFeedResponseSerializer.FromFeedResponseStream <TInput>(
serializerCore,
responseMessage.Content);
ReadFeedResponse <TInput> readFeedResponse = new ReadFeedResponse <TInput>(
httpStatusCode: responseMessage.StatusCode,
resources: resources,
responseMessageHeaders: responseMessage.Headers,
diagnostics: responseMessage.Diagnostics);
return(readFeedResponse);
}
}
private FeedResponse <T> CreateQueryFeedResponseHelper <T>(
ResponseMessage cosmosResponseMessage,
Documents.ResourceType resourceType)
{
//Throw the exception
cosmosResponseMessage.EnsureSuccessStatusCode();
QueryResponse queryResponse = cosmosResponseMessage as QueryResponse;
if (queryResponse != null)
{
return(QueryResponse <T> .CreateResponse <T>(
cosmosQueryResponse : queryResponse,
serializerCore : this.serializerCore));
}
return(ReadFeedResponse <T> .CreateResponse <T>(
cosmosResponseMessage,
this.serializerCore,
resourceType));
}
public override async Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
string resourceUri,
ResourceType resourceType,
OperationType operationType,
SqlQuerySpec sqlQuerySpec,
PartitionKey?partitionKey,
string supportedQueryFeatures,
Guid clientQueryCorrelationId,
ITrace trace,
CancellationToken cancellationToken)
{
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo;
using (ResponseMessage message = await this.clientContext.ProcessResourceOperationStreamAsync(
resourceUri: resourceUri,
resourceType: resourceType,
operationType: operationType,
requestOptions: null,
feedRange: partitionKey.HasValue ? new FeedRangePartitionKey(partitionKey.Value) : null,
cosmosContainerCore: this.cosmosContainerCore,
streamPayload: this.clientContext.SerializerCore.ToStreamSqlQuerySpec(sqlQuerySpec, resourceType),
requestEnricher: (requestMessage) =>
{
requestMessage.Headers.Add(HttpConstants.HttpHeaders.ContentType, RuntimeConstants.MediaTypes.QueryJson);
requestMessage.Headers.Add(HttpConstants.HttpHeaders.IsQueryPlanRequest, bool.TrueString);
requestMessage.Headers.Add(HttpConstants.HttpHeaders.SupportedQueryFeatures, supportedQueryFeatures);
requestMessage.Headers.Add(HttpConstants.HttpHeaders.QueryVersion, new Version(major: 1, minor: 0).ToString());
requestMessage.Headers.Add(WFConstants.BackendHeaders.CorrelatedActivityId, clientQueryCorrelationId.ToString());
requestMessage.UseGatewayMode = true;
},
trace: trace,
cancellationToken: cancellationToken))
{
// Syntax exception are argument exceptions and thrown to the user.
message.EnsureSuccessStatusCode();
partitionedQueryExecutionInfo = this.clientContext.SerializerCore.FromStream <PartitionedQueryExecutionInfo>(message.Content);
}
return(partitionedQueryExecutionInfo);
}
public void ValidateErrorHandling()
{
Error error = new Error()
{
Code = System.Net.HttpStatusCode.BadRequest.ToString(),
Message = "Unsupported Query",
AdditionalErrorInfo = "Additional error info message",
};
CosmosDiagnosticsContext diagnostics = new CosmosDiagnosticsContextCore();
CosmosException cosmosException = CosmosExceptionFactory.CreateBadRequestException(
error.ToString(),
error: error,
diagnosticsContext: diagnostics);
ResponseMessage responseMessage = QueryResponse.CreateFailure(
statusCode: System.Net.HttpStatusCode.BadRequest,
cosmosException: cosmosException,
requestMessage: null,
diagnostics: diagnostics,
responseHeaders: null);
Assert.AreEqual(error, responseMessage.CosmosException.Error);
Assert.IsTrue(responseMessage.ErrorMessage.Contains(error.Message));
Assert.IsTrue(responseMessage.ErrorMessage.Contains(error.AdditionalErrorInfo));
try
{
responseMessage.EnsureSuccessStatusCode();
Assert.Fail("Should throw exception");
}
catch (CosmosException ce) when(ce.StatusCode == HttpStatusCode.BadRequest)
{
Assert.IsTrue(ce.Message.Contains(error.Message));
Assert.IsTrue(ce.ToString().Contains(error.Message));
Assert.IsTrue(ce.ToString().Contains(error.AdditionalErrorInfo));
}
}
private FeedResponse <T> CreateQueryFeedResponseHelper <T>(
ResponseMessage cosmosResponseMessage,
bool usePropertySerializer)
{
//Throw the exception
cosmosResponseMessage.EnsureSuccessStatusCode();
// The property serializer should be used for internal
// query operations like throughput since user serializer can break the logic
CosmosSerializer serializer = usePropertySerializer ? this.propertiesSerializer : this.cosmosSerializer;
QueryResponse queryResponse = cosmosResponseMessage as QueryResponse;
if (queryResponse != null)
{
return(QueryResponse <T> .CreateResponse <T>(
cosmosQueryResponse : queryResponse,
jsonSerializer : serializer));
}
return(ReadFeedResponse <T> .CreateResponse <T>(
cosmosResponseMessage,
serializer));
}
public void EnsureSuccessStatusCode_ThrowsOnFailure()
{
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.NotFound);
Assert.ThrowsException <CosmosException>(() => responseMessage.EnsureSuccessStatusCode());
}
public void EnsureSuccessStatusCode_DontThrowOnSuccess()
{
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK);
responseMessage.EnsureSuccessStatusCode();
}
