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(); }