public static async Task <PartitionedQueryExecutionInfo> GetQueryPlanWithServiceInteropAsync(
CosmosQueryClient queryClient,
SqlQuerySpec sqlQuerySpec,
PartitionKeyDefinition partitionKeyDefinition,
bool hasLogicalPartitionKey,
ITrace trace,
CancellationToken cancellationToken = default)
{
if (queryClient == null)
{
throw new ArgumentNullException(nameof(queryClient));
}
if (sqlQuerySpec == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpec));
}
if (partitionKeyDefinition == null)
{
throw new ArgumentNullException(nameof(partitionKeyDefinition));
}
cancellationToken.ThrowIfCancellationRequested();
using (ITrace serviceInteropTrace = trace.StartChild("Service Interop Query Plan", TraceComponent.Query, TraceLevel.Info))
{
QueryPlanHandler queryPlanHandler = new QueryPlanHandler(queryClient);
TryCatch <PartitionedQueryExecutionInfo> tryGetQueryPlan = await queryPlanHandler.TryGetQueryPlanAsync(
sqlQuerySpec,
partitionKeyDefinition,
QueryPlanRetriever.SupportedQueryFeatures,
hasLogicalPartitionKey,
cancellationToken);
if (!tryGetQueryPlan.Succeeded)
{
if (tryGetQueryPlan.Exception is CosmosException)
{
throw tryGetQueryPlan.Exception;
}
throw CosmosExceptionFactory.CreateBadRequestException(
message: tryGetQueryPlan.Exception.ToString(),
stackTrace: tryGetQueryPlan.Exception.StackTrace);
}
return(tryGetQueryPlan.Result);
}
}
public async Task FeedEstimatorRunner_TransientErrorsShouldContinue()
{
const long estimation = 10;
bool detectedEstimationCorrectly = false;
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(500);
Task estimatorDispatcher(long detectedEstimation, CancellationToken token)
{
detectedEstimationCorrectly = estimation == detectedEstimation;
cancellationTokenSource.Cancel();
return(Task.CompletedTask);
}
Mock <FeedResponse <ChangeFeedProcessorState> > mockedResponse = new Mock <FeedResponse <ChangeFeedProcessorState> >();
mockedResponse.Setup(r => r.Count).Returns(1);
mockedResponse.Setup(r => r.GetEnumerator()).Returns(new List <ChangeFeedProcessorState>()
{
new ChangeFeedProcessorState(string.Empty, estimation, string.Empty)
}.GetEnumerator());
CosmosException exception = CosmosExceptionFactory.CreateThrottledException("throttled", new Headers());
Mock <FeedIterator <ChangeFeedProcessorState> > mockedIterator = new Mock <FeedIterator <ChangeFeedProcessorState> >();
mockedIterator.SetupSequence(i => i.ReadNextAsync(It.IsAny <CancellationToken>()))
.ThrowsAsync(exception)
.ReturnsAsync(mockedResponse.Object);
Mock <ChangeFeedEstimator> mockedEstimator = new Mock <ChangeFeedEstimator>();
mockedEstimator.Setup(e => e.GetCurrentStateIterator(It.IsAny <ChangeFeedEstimatorRequestOptions>())).Returns(mockedIterator.Object);
Mock <ChangeFeedProcessorHealthMonitor> healthMonitor = new Mock <ChangeFeedProcessorHealthMonitor>();
FeedEstimatorRunner estimatorCore = new FeedEstimatorRunner(estimatorDispatcher, mockedEstimator.Object, healthMonitor.Object, TimeSpan.FromMilliseconds(10));
try
{
await estimatorCore.RunAsync(cancellationTokenSource.Token);
}
catch (TaskCanceledException)
{
// expected
}
Assert.IsTrue(detectedEstimationCorrectly);
mockedIterator.Verify(i => i.ReadNextAsync(It.IsAny <CancellationToken>()), Times.Exactly(2));
healthMonitor
.Verify(m => m.NotifyErrorAsync(It.IsAny <string>(), exception), Times.Once);
}
internal async Task <ThroughputResponse> ReplaceThroughputPropertiesIfExistsAsync(
string targetRID,
ThroughputProperties throughputProperties,
RequestOptions requestOptions,
CancellationToken cancellationToken = default(CancellationToken))
{
try
{
ThroughputProperties currentProperty = await this.GetOfferV2Async <ThroughputProperties>(targetRID, failIfNotConfigured : false, cancellationToken : cancellationToken);
if (currentProperty == null)
{
CosmosException notFound = CosmosExceptionFactory.CreateNotFoundException(
$"Throughput is not configured for {targetRID}");
return(new ThroughputResponse(
httpStatusCode: notFound.StatusCode,
headers: notFound.Headers,
throughputProperties: null,
diagnostics: notFound.Diagnostics));
}
currentProperty.Content = throughputProperties.Content;
return(await this.GetThroughputResponseAsync(
streamPayload : this.ClientContext.SerializerCore.ToStream(currentProperty),
operationType : OperationType.Replace,
linkUri : new Uri(currentProperty.SelfLink, UriKind.Relative),
resourceType : ResourceType.Offer,
requestOptions : requestOptions,
cancellationToken : cancellationToken));
}
catch (DocumentClientException dce)
{
ResponseMessage responseMessage = dce.ToCosmosResponseMessage(null);
return(new ThroughputResponse(
responseMessage.StatusCode,
headers: responseMessage.Headers,
throughputProperties: null,
diagnostics: responseMessage.Diagnostics));
}
catch (AggregateException ex)
{
ResponseMessage responseMessage = TransportHandler.AggregateExceptionConverter(ex, null);
return(new ThroughputResponse(
responseMessage.StatusCode,
headers: responseMessage.Headers,
throughputProperties: null,
diagnostics: responseMessage.Diagnostics));
}
}
public override CosmosException Visit(MalformedContinuationTokenException malformedContinuationTokenException, ITrace trace)
{
Headers headers = new Headers()
{
SubStatusCode = Documents.SubStatusCodes.MalformedContinuationToken
};
return(CosmosExceptionFactory.CreateBadRequestException(
message: malformedContinuationTokenException.Message,
headers: headers,
stackTrace: malformedContinuationTokenException.StackTrace,
innerException: malformedContinuationTokenException,
trace: trace));
}
/// <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))
{
CosmosDiagnosticsContext diagnostics = CosmosDiagnosticsContext.Create(this.changeFeedOptions);
using (diagnostics.GetOverallScope())
{
diagnostics.AddDiagnosticsInternal(new FeedRangeStatistics(this.FeedRangeInternal));
if (!this.lazyContainerRid.ValueInitialized)
{
using (diagnostics.CreateScope("InitializeContainerResourceId"))
{
TryCatch <string> tryInitializeContainerRId = await this.lazyContainerRid.GetValueAsync(cancellationToken);
if (!tryInitializeContainerRId.Succeeded)
{
if (!(tryInitializeContainerRId.Exception.InnerException is CosmosException cosmosException))
{
throw new InvalidOperationException("Failed to convert to CosmosException.");
}
return(cosmosException.ToCosmosResponseMessage(
new RequestMessage(
method: null,
requestUriString: null,
diagnosticsContext: diagnostics)));
}
}
using (diagnostics.CreateScope("InitializeContinuation"))
{
if (this.FeedRangeContinuation != null)
{
TryCatch validateContainer = this.FeedRangeContinuation.ValidateContainer(this.lazyContainerRid.Result.Result);
if (!validateContainer.Succeeded)
{
return(CosmosExceptionFactory.CreateBadRequestException(
message: validateContainer.Exception.InnerException.Message,
innerException: validateContainer.Exception.InnerException,
diagnosticsContext: diagnostics).ToCosmosResponseMessage(new RequestMessage(method: null, requestUriString: null, diagnosticsContext: diagnostics)));
}
}
await this.InitializeFeedContinuationAsync(cancellationToken);
}
}
return(await this.ReadNextInternalAsync(diagnostics, cancellationToken));
}
}
private static QueryResponseCore CreateFromDocumentClientException(Microsoft.Azure.Documents.DocumentClientException documentClientException)
{
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentClientException,
null);
QueryResponseCore queryResponseCore = QueryResponseCore.CreateFailure(
statusCode: documentClientException.StatusCode.GetValueOrDefault(System.Net.HttpStatusCode.InternalServerError),
subStatusCodes: null,
cosmosException: cosmosException,
requestCharge: 0,
activityId: documentClientException.ActivityId);
return(queryResponseCore);
}
/// <summary>
/// Gets the container's Properties by using the internal cache.
/// In case the cache does not have information about this container, it may end up making a server call to fetch the data.
/// </summary>
/// <param name="cancellationToken"><see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>A <see cref="Task"/> containing the <see cref="ContainerProperties"/> for this container.</returns>
internal override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
ClientCollectionCache collectionCache = await this.ClientContext.DocumentClient.GetCollectionCacheAsync();
try
{
return(await collectionCache.ResolveByNameAsync(HttpConstants.Versions.CurrentVersion, this.LinkUri.OriginalString, cancellationToken));
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(
dce: ex,
diagnosticsContext: null);
}
}
private ShouldRetryResult GetShouldRetryFromException(
Exception exception)
{
if (exception is OperationCanceledException operationCanceledException)
{
// throw timeout if the cancellationToken is not canceled (i.e. httpClient timed out)
string message =
$"GatewayStoreClient Request Timeout. Start Time Utc:{this.startDateTimeUtc}; Total Duration:{(DateTime.UtcNow - this.startDateTimeUtc).TotalMilliseconds} Ms; Http Client Timeout:{this.gatewayRequestTimeout.TotalMilliseconds} Ms; Activity id: {Trace.CorrelationManager.ActivityId.ToString()};";
return(ShouldRetryResult.NoRetry(CosmosExceptionFactory.CreateRequestTimeoutException(
message,
innerException: operationCanceledException,
diagnosticsContext: this.diagnosticsContext)));
}
return(ShouldRetryResult.NoRetry());
}
public async Task ProcessChanges_WhenCheckpointThrows_ShouldThrow()
{
CosmosException original = CosmosExceptionFactory.CreateThrottledException("throttled", new Headers());
Mock <PartitionCheckpointer> checkpointer = new Mock <PartitionCheckpointer>();
checkpointer.Setup(c => c.CheckpointPartitionAsync(It.IsAny <string>())).ThrowsAsync(original);
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.Headers.ContinuationToken = Guid.NewGuid().ToString();
ChangeFeedObserverContextCore observerContext = new ChangeFeedObserverContextCore(Guid.NewGuid().ToString(), feedResponse: responseMessage, checkpointer.Object);
CosmosException caught = await Assert.ThrowsExceptionAsync <CosmosException>(() => this.sut.ProcessChangesAsync(observerContext, this.stream, CancellationToken.None));
Assert.AreEqual(original, caught);
}
internal static ResponseMessage ToCosmosResponseMessage(this DocumentServiceResponse documentServiceResponse, RequestMessage requestMessage)
{
Debug.Assert(requestMessage != null, nameof(requestMessage));
Headers headers = documentServiceResponse.Headers.ToCosmosHeaders();
// Only record point operation stats if ClientSideRequestStats did not record the response.
CosmosClientSideRequestStatistics clientSideRequestStatistics = documentServiceResponse.RequestStats as CosmosClientSideRequestStatistics;
if (clientSideRequestStatistics == null ||
(clientSideRequestStatistics.ContactedReplicas.Count == 0 && clientSideRequestStatistics.FailedReplicas.Count == 0))
{
requestMessage.DiagnosticsContext.AddDiagnosticsInternal(new PointOperationStatistics(
activityId: headers.ActivityId,
responseTimeUtc: DateTime.UtcNow,
statusCode: documentServiceResponse.StatusCode,
subStatusCode: documentServiceResponse.SubStatusCode,
requestCharge: headers.RequestCharge,
errorMessage: null,
method: requestMessage?.Method,
requestUri: requestMessage?.RequestUri,
requestSessionToken: requestMessage?.Headers?.Session,
responseSessionToken: headers.Session));
}
// If it's considered a failure create the corresponding CosmosException
if (!documentServiceResponse.StatusCode.IsSuccess())
{
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentServiceResponse,
headers,
requestMessage);
return(cosmosException.ToCosmosResponseMessage(requestMessage));
}
ResponseMessage responseMessage = new ResponseMessage(
statusCode: documentServiceResponse.StatusCode,
requestMessage: requestMessage,
headers: headers,
cosmosException: null,
diagnostics: requestMessage.DiagnosticsContext)
{
Content = documentServiceResponse.ResponseBody
};
return(responseMessage);
}
public async Task TryCheckpoint_OnCosmosException()
{
CosmosException cosmosException = CosmosExceptionFactory.CreateThrottledException("throttled", new Headers());
string leaseToken = Guid.NewGuid().ToString();
string continuation = Guid.NewGuid().ToString();
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK);
responseMessage.Headers.ContinuationToken = continuation;
Mock <PartitionCheckpointer> checkpointer = new Mock <PartitionCheckpointer>();
checkpointer.Setup(c => c.CheckpointPartitionAsync(It.Is <string>(s => s == continuation))).ThrowsAsync(cosmosException);
ChangeFeedObserverContextCore changeFeedObserverContextCore = new ChangeFeedObserverContextCore(leaseToken, responseMessage, checkpointer.Object);
CosmosException exception = await Assert.ThrowsExceptionAsync <CosmosException>(() => changeFeedObserverContextCore.CheckpointAsync());
Assert.ReferenceEquals(cosmosException, exception);
}
public void EnsureCorrectStatusCode()
{
string testMessage = "Test" + Guid.NewGuid().ToString();
string activityId = Guid.NewGuid().ToString();
int substatuscode = 9000;
string substatus = substatuscode.ToString();
double requestCharge = 42;
double retryAfter = 9000;
string retryAfterLiteral = retryAfter.ToString();
List <(HttpStatusCode statusCode, CosmosException exception)> exceptionsToStatusCodes = new List <(HttpStatusCode, CosmosException)>()
{
(HttpStatusCode.NotFound, CosmosExceptionFactory.CreateNotFoundException(testMessage, new Headers()
{
SubStatusCodeLiteral = substatus, ActivityId = activityId, RequestCharge = requestCharge, RetryAfterLiteral = retryAfterLiteral
})),
(HttpStatusCode.InternalServerError, CosmosExceptionFactory.CreateInternalServerErrorException(testMessage, new Headers()
{
SubStatusCodeLiteral = substatus, ActivityId = activityId, RequestCharge = requestCharge, RetryAfterLiteral = retryAfterLiteral
})),
(HttpStatusCode.BadRequest, CosmosExceptionFactory.CreateBadRequestException(testMessage, new Headers()
{
SubStatusCodeLiteral = substatus, ActivityId = activityId, RequestCharge = requestCharge, RetryAfterLiteral = retryAfterLiteral
})),
(HttpStatusCode.RequestTimeout, CosmosExceptionFactory.CreateRequestTimeoutException(testMessage, new Headers()
{
SubStatusCodeLiteral = substatus, ActivityId = activityId, RequestCharge = requestCharge, RetryAfterLiteral = retryAfterLiteral
})),
((HttpStatusCode)429, CosmosExceptionFactory.CreateThrottledException(testMessage, new Headers()
{
SubStatusCodeLiteral = substatus, ActivityId = activityId, RequestCharge = requestCharge, RetryAfterLiteral = retryAfterLiteral
})),
};
foreach ((HttpStatusCode statusCode, CosmosException exception) in exceptionsToStatusCodes)
{
this.ValidateExceptionInfo(
exception,
statusCode,
substatus,
testMessage,
activityId,
requestCharge,
retryAfter);
}
}
public void EnsureCorrectStatusCode()
{
string testMessage = "Test" + Guid.NewGuid().ToString();
List <(HttpStatusCode statusCode, CosmosException exception)> exceptionsToStatusCodes = new List <(HttpStatusCode, CosmosException)>()
{
(HttpStatusCode.NotFound, CosmosExceptionFactory.CreateNotFoundException(testMessage, activityId: Guid.NewGuid().ToString())),
(HttpStatusCode.InternalServerError, CosmosExceptionFactory.CreateInternalServerErrorException(testMessage, activityId: Guid.NewGuid().ToString())),
(HttpStatusCode.BadRequest, CosmosExceptionFactory.CreateBadRequestException(testMessage, activityId: Guid.NewGuid().ToString())),
(HttpStatusCode.RequestTimeout, CosmosExceptionFactory.CreateRequestTimeoutException(testMessage, activityId: Guid.NewGuid().ToString())),
((HttpStatusCode)429, CosmosExceptionFactory.CreateThrottledException(testMessage, activityId: Guid.NewGuid().ToString())),
};
foreach ((HttpStatusCode statusCode, CosmosException exception)item in exceptionsToStatusCodes)
{
this.ValidateExceptionInfo(item.exception, item.statusCode, testMessage);
}
}
internal static ResponseMessage ToCosmosResponseMessage(this DocumentClientException documentClientException, RequestMessage requestMessage)
{
CosmosDiagnosticsContext diagnosticsContext = requestMessage?.DiagnosticsContext;
if (diagnosticsContext == null)
{
diagnosticsContext = CosmosDiagnosticsContextCore.Create();
}
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentClientException,
diagnosticsContext);
PointOperationStatistics pointOperationStatistics = new PointOperationStatistics(
activityId: cosmosException.Headers.ActivityId,
statusCode: cosmosException.StatusCode,
subStatusCode: (int)SubStatusCodes.Unknown,
requestCharge: cosmosException.Headers.RequestCharge,
errorMessage: cosmosException.Message,
method: requestMessage?.Method,
requestUri: requestMessage?.RequestUri,
requestSessionToken: requestMessage?.Headers?.Session,
responseSessionToken: cosmosException.Headers.Session,
clientSideRequestStatistics: documentClientException.RequestStatistics as CosmosClientSideRequestStatistics);
diagnosticsContext.AddDiagnosticsInternal(pointOperationStatistics);
// if StatusCode is null it is a client business logic error and it never hit the backend, so throw
if (documentClientException.StatusCode == null)
{
throw cosmosException;
}
// if there is a status code then it came from the backend, return error as http error instead of throwing the exception
ResponseMessage responseMessage = cosmosException.ToCosmosResponseMessage(requestMessage);
if (requestMessage != null)
{
requestMessage.Properties.Remove(nameof(DocumentClientException));
requestMessage.Properties.Add(nameof(DocumentClientException), documentClientException);
}
return(responseMessage);
}
public static CosmosException CreateFromException(Exception exception)
{
if (exception is CosmosException cosmosException)
{
return(cosmosException);
}
if (exception is Microsoft.Azure.Documents.DocumentClientException documentClientException)
{
return(CreateFromDocumentClientException(documentClientException));
}
if (exception is QueryException queryException)
{
return(queryException.Accept(QueryExceptionConverter.Singleton));
}
if (exception is ChangeFeedException changeFeedException)
{
return(changeFeedException.Accept(ChangeFeedExceptionConverter.Singleton));
}
if (exception is ExceptionWithStackTraceException exceptionWithStackTrace)
{
return(CreateFromExceptionWithStackTrace(exceptionWithStackTrace));
}
if (exception.InnerException != null)
{
// retry with the inner exception
return(ExceptionToCosmosException.CreateFromException(exception.InnerException));
}
return(CosmosExceptionFactory.CreateInternalServerErrorException(
message: exception.Message,
stackTrace: exception.StackTrace,
headers: new Headers()
{
ActivityId = EmptyGuidString,
},
trace: NoOpTrace.Singleton,
innerException: exception));
}
/// <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)
{
CosmosDiagnosticsContext diagnostics = CosmosDiagnosticsContext.Create(this.queryRequestOptions);
using (diagnostics.GetOverallScope())
{
if (!this.lazyContainerRid.ValueInitialized)
{
using (diagnostics.CreateScope("InitializeContainerResourceId"))
{
TryCatch <string> tryInitializeContainerRId = await this.lazyContainerRid.GetValueAsync(cancellationToken);
if (!tryInitializeContainerRId.Succeeded)
{
CosmosException cosmosException = tryInitializeContainerRId.Exception.InnerException as CosmosException;
return(cosmosException.ToCosmosResponseMessage(new RequestMessage(method: null, requestUri: null, diagnosticsContext: diagnostics)));
}
}
using (diagnostics.CreateScope("InitializeContinuation"))
{
if (this.FeedRangeContinuation != null)
{
TryCatch validateContainer = this.FeedRangeContinuation.ValidateContainer(this.lazyContainerRid.Result.Result);
if (!validateContainer.Succeeded)
{
return(CosmosExceptionFactory.CreateBadRequestException(
message: validateContainer.Exception.InnerException.Message,
innerException: validateContainer.Exception.InnerException,
diagnosticsContext: diagnostics).ToCosmosResponseMessage(new RequestMessage(method: null, requestUri: null, diagnosticsContext: diagnostics)));
}
}
else
{
await this.InitializeFeedContinuationAsync(cancellationToken);
}
}
}
return(await this.ReadNextInternalAsync(diagnostics, cancellationToken));
}
}
private static CosmosException CreateFromExceptionWithStackTrace(ExceptionWithStackTraceException exceptionWithStackTrace)
{
// Use the original stack trace from the inner exception.
if (exceptionWithStackTrace.InnerException is Microsoft.Azure.Documents.DocumentClientException ||
exceptionWithStackTrace.InnerException is CosmosException)
{
return(ExceptionToCosmosException.CreateFromException(exceptionWithStackTrace.InnerException));
}
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(exceptionWithStackTrace.InnerException);
return(CosmosExceptionFactory.Create(
cosmosException.StatusCode,
cosmosException.Message,
exceptionWithStackTrace.StackTrace,
headers: cosmosException.Headers,
cosmosException.Trace,
cosmosException.Error,
cosmosException.InnerException));
}
public async Task <ThroughputResponse> ReadThroughputAsync(
RequestOptions requestOptions,
ITrace trace,
CancellationToken cancellationToken = default)
{
ThroughputResponse throughputResponse = await this.ReadThroughputIfExistsAsync(
requestOptions,
trace,
cancellationToken);
if (throughputResponse.StatusCode == HttpStatusCode.NotFound)
{
throw CosmosExceptionFactory.CreateNotFoundException(
message: $"Throughput is not configured for {this.Id}",
headers: throughputResponse.Headers,
trace: trace);
}
return(throughputResponse);
}
public async Task CheckpointAsync()
{
try
{
await this.checkpointer.CheckpointPartitionAsync(this.responseMessage.Headers.ContinuationToken);
}
catch (LeaseLostException leaseLostException)
{
// LeaseLost means another instance stole the lease due to load balancing, so the right status is 412
CosmosException cosmosException = CosmosExceptionFactory.Create(
statusCode: HttpStatusCode.PreconditionFailed,
message: "Lease was lost due to load balancing and will be processed by another instance",
stackTrace: leaseLostException.StackTrace,
headers: new Headers(),
trace: NoOpTrace.Singleton,
error: null,
innerException: leaseLostException);
throw cosmosException;
}
}
private void HandleFailedRequest(
ResponseMessage responseMessage,
string lastContinuation)
{
DocDbError docDbError = ExceptionClassifier.ClassifyStatusCodes(responseMessage.StatusCode, (int)responseMessage.Headers.SubStatusCode);
switch (docDbError)
{
case DocDbError.PartitionSplit:
throw new FeedRangeGoneException("Partition split.", lastContinuation);
case DocDbError.Undefined:
throw CosmosExceptionFactory.Create(responseMessage);
default:
DefaultTrace.TraceCritical($"Unrecognized DocDbError enum value {docDbError}");
Debug.Fail($"Unrecognized DocDbError enum value {docDbError}");
throw new InvalidOperationException($"Unrecognized DocDbError enum value {docDbError} for status code {responseMessage.StatusCode} and substatus code {responseMessage.Headers.SubStatusCode}");
}
}
internal async Task <(DataEncryptionKeyProperties, InMemoryRawDek)> FetchUnwrappedByRidAsync(
string rid,
CosmosDiagnosticsContext diagnosticsContext,
CancellationToken cancellationToken)
{
string dekRidSelfLink = PathsHelper.GeneratePath(ResourceType.ClientEncryptionKey, rid, isFeed: false);
// Server self links end with / but client generate links don't - match them.
if (!dekRidSelfLink.EndsWith("/"))
{
dekRidSelfLink += "/";
}
DataEncryptionKeyProperties dekProperties = null;
try
{
dekProperties = await this.ClientContext.DekCache.GetOrAddByRidSelfLinkAsync(
dekRidSelfLink,
this.Database.Id,
this.ReadResourceByRidSelfLinkAsync,
this.LinkUri,
diagnosticsContext,
cancellationToken);
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
throw CosmosExceptionFactory.CreateNotFoundException(
ClientResources.DataEncryptionKeyNotFound,
diagnosticsContext: diagnosticsContext,
innerException: ex);
}
InMemoryRawDek inMemoryRawDek = await this.ClientContext.DekCache.GetOrAddRawDekAsync(
dekProperties,
this.UnwrapAsync,
diagnosticsContext,
cancellationToken);
return(dekProperties, inMemoryRawDek);
}
internal override async Task <List <Documents.Routing.Range <string> > > GetEffectiveRangesAsync(
IRoutingMapProvider routingMapProvider,
string containerRid,
Documents.PartitionKeyDefinition partitionKeyDefinition,
ITrace trace)
{
Documents.PartitionKeyRange pkRange = await routingMapProvider.TryGetPartitionKeyRangeByIdAsync(
collectionResourceId : containerRid,
partitionKeyRangeId : this.PartitionKeyRangeId,
trace : trace,
forceRefresh : false);
if (pkRange == null)
{
// Try with a refresh
pkRange = await routingMapProvider.TryGetPartitionKeyRangeByIdAsync(
collectionResourceId : containerRid,
partitionKeyRangeId : this.PartitionKeyRangeId,
trace : trace,
forceRefresh : true);
}
if (pkRange == null)
{
throw CosmosExceptionFactory.Create(
statusCode: HttpStatusCode.Gone,
message: $"The PartitionKeyRangeId: \"{this.PartitionKeyRangeId}\" is not valid for the current container {containerRid} .",
stackTrace: string.Empty,
headers: new Headers()
{
SubStatusCode = SubStatusCodes.PartitionKeyRangeGone,
},
error: null,
innerException: null,
trace: NoOpTrace.Singleton);
}
return(new List <Documents.Routing.Range <string> > {
pkRange.ToRange()
});
}
/// <summary>
/// Gets the container's Properties by using the internal cache.
/// In case the cache does not have information about this container, it may end up making a server call to fetch the data.
/// </summary>
/// <param name="forceRefresh">Forces the cache to refresh</param>
/// <param name="cancellationToken"><see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>A <see cref="Task"/> containing the <see cref="ContainerProperties"/> for this container.</returns>
public override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(
bool forceRefresh = false,
CancellationToken cancellationToken = default)
{
try
{
ClientCollectionCache collectionCache = await this.ClientContext.DocumentClient.GetCollectionCacheAsync();
return(await collectionCache.ResolveByNameAsync(
HttpConstants.Versions.CurrentVersion,
this.LinkUri,
forceRefresh,
cancellationToken));
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(
dce: ex,
diagnosticsContext: null);
}
}
public void FeedRangeResponse_ResponseIsAccessible()
{
ResponseMessage original = new ResponseMessage(
System.Net.HttpStatusCode.OK,
new RequestMessage(),
new Headers(),
CosmosExceptionFactory.CreateBadRequestException("test"),
CosmosDiagnosticsContext.Create(new RequestOptions()));
original.Content = Mock.Of <MemoryStream>();
Mock <FeedRangeContinuation> feedContinuation = new Mock <FeedRangeContinuation>();
ResponseMessage feedRangeResponse = FeedRangeResponse.CreateSuccess(original, feedContinuation.Object);
Assert.AreEqual(original.Content, feedRangeResponse.Content);
Assert.AreEqual(original.StatusCode, feedRangeResponse.StatusCode);
Assert.AreEqual(original.RequestMessage, feedRangeResponse.RequestMessage);
Assert.AreEqual(original.Headers, feedRangeResponse.Headers);
Assert.AreEqual(original.CosmosException, feedRangeResponse.CosmosException);
Assert.AreEqual(original.DiagnosticsContext, feedRangeResponse.DiagnosticsContext);
}
public async Task <ThroughputResponse> ReplaceThroughputAsync(
CosmosDiagnosticsContext diagnosticsContext,
ThroughputProperties throughputProperties,
RequestOptions requestOptions = null,
CancellationToken cancellationToken = default)
{
ThroughputResponse throughputResponse = await this.ReplaceThroughputIfExistsAsync(
diagnosticsContext,
throughputProperties,
requestOptions,
cancellationToken);
if (throughputResponse.StatusCode == HttpStatusCode.NotFound)
{
throw CosmosExceptionFactory.CreateNotFoundException(
message: $"Throughput is not configured for {this.Id}",
headers: throughputResponse.Headers,
diagnosticsContext: diagnosticsContext);
}
return(throughputResponse);
}
public void FeedRangeResponse_ResponseIsAccessible()
{
Headers headers = new Headers();
ResponseMessage original = new ResponseMessage(
System.Net.HttpStatusCode.OK,
new RequestMessage(),
headers,
CosmosExceptionFactory.CreateBadRequestException("test", headers),
NoOpTrace.Singleton)
{
Content = Mock.Of <MemoryStream>()
};
Mock <FeedRangeContinuation> feedContinuation = new Mock <FeedRangeContinuation>();
ResponseMessage feedRangeResponse = FeedRangeResponse.CreateSuccess(original, feedContinuation.Object);
Assert.AreEqual(original.Content, feedRangeResponse.Content);
Assert.AreEqual(original.StatusCode, feedRangeResponse.StatusCode);
Assert.AreEqual(original.RequestMessage, feedRangeResponse.RequestMessage);
Assert.AreEqual(original.Headers, feedRangeResponse.Headers);
Assert.AreEqual(original.CosmosException, feedRangeResponse.CosmosException);
}
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));
}
}
internal override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(
string containerUri,
CancellationToken cancellationToken = default(CancellationToken))
{
CosmosDiagnosticsContextCore diagnosticsContext = new CosmosDiagnosticsContextCore();
ClientCollectionCache collectionCache = await this.DocumentClient.GetCollectionCacheAsync();
try
{
using (diagnosticsContext.CreateScope("ContainerCache.ResolveByNameAsync"))
{
return(await collectionCache.ResolveByNameAsync(
HttpConstants.Versions.CurrentVersion,
containerUri,
cancellationToken));
}
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(ex, diagnosticsContext);
}
}
public override async Task <List <Documents.Routing.Range <string> > > GetEffectiveRangesAsync(
IRoutingMapProvider routingMapProvider,
string containerRid,
Documents.PartitionKeyDefinition partitionKeyDefinition)
{
Documents.PartitionKeyRange pkRange = await routingMapProvider.TryGetPartitionKeyRangeByIdAsync(
collectionResourceId : containerRid,
partitionKeyRangeId : this.PartitionKeyRangeId,
forceRefresh : false);
if (pkRange == null)
{
// Try with a refresh
pkRange = await routingMapProvider.TryGetPartitionKeyRangeByIdAsync(
collectionResourceId : containerRid,
partitionKeyRangeId : this.PartitionKeyRangeId,
forceRefresh : true);
}
if (pkRange == null)
{
throw CosmosExceptionFactory.Create(
statusCode: HttpStatusCode.Gone,
subStatusCode: (int)SubStatusCodes.PartitionKeyRangeGone,
message: $"The PartitionKeyRangeId: \"{this.PartitionKeyRangeId}\" is not valid for the current container {containerRid} .",
stackTrace: string.Empty,
activityId: string.Empty,
requestCharge: 0,
retryAfter: null,
headers: null,
diagnosticsContext: null,
error: null,
innerException: null);
}
return(new List <Documents.Routing.Range <string> > {
pkRange.ToRange()
});
}
internal static ResponseMessage ToCosmosResponseMessage(this StoreResponse storeResponse, RequestMessage requestMessage)
{
// If it's considered a failure create the corresponding CosmosException
if (!storeResponse.StatusCode.IsSuccess())
{
CosmosException cosmosException = CosmosExceptionFactory.Create(
storeResponse,
requestMessage);
return(cosmosException.ToCosmosResponseMessage(requestMessage));
}
// Is status code conversion lossy?
ResponseMessage responseMessage = new ResponseMessage((HttpStatusCode)storeResponse.Status, requestMessage);
if (storeResponse.ResponseBody != null)
{
responseMessage.Content = storeResponse.ResponseBody;
}
return(responseMessage);
}