internal override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(
string containerUri,
CancellationToken cancellationToken)
{
this.ThrowIfDisposed();
CosmosDiagnosticsContext diagnosticsContext = CosmosDiagnosticsContextCore.Create(requestOptions: null);
using (diagnosticsContext.GetOverallScope())
{
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);
}
}
}
private static QueryResponseCore CreateFromExceptionWithStackTrace(ExceptionWithStackTraceException exceptionWithStackTrace)
{
// Use the original stack trace from the inner exception.
if (exceptionWithStackTrace.InnerException is DocumentClientException ||
exceptionWithStackTrace.InnerException is CosmosException)
{
return(QueryResponseFactory.CreateFromException(exceptionWithStackTrace.InnerException));
}
QueryResponseCore queryResponseCore = QueryResponseFactory.CreateFromException(exceptionWithStackTrace.InnerException);
CosmosException cosmosException = queryResponseCore.CosmosException;
queryResponseCore = QueryResponseCore.CreateFailure(
statusCode: queryResponseCore.StatusCode,
subStatusCodes: queryResponseCore.SubStatusCode,
cosmosException: CosmosExceptionFactory.Create(
statusCode: cosmosException.StatusCode,
message: cosmosException.Message,
stackTrace: exceptionWithStackTrace.StackTrace,
headers: cosmosException.Headers,
trace: cosmosException.Trace,
error: cosmosException.Error,
innerException: cosmosException.InnerException),
requestCharge: queryResponseCore.RequestCharge,
activityId: queryResponseCore.ActivityId);
return(queryResponseCore);
}
private static bool TryCreateFromExceptionWithStackTrace(
ExceptionWithStackTraceException exceptionWithStackTrace,
ITrace trace,
out CosmosException cosmosException)
{
// Use the original stack trace from the inner exception.
if (exceptionWithStackTrace.InnerException is Microsoft.Azure.Documents.DocumentClientException ||
exceptionWithStackTrace.InnerException is CosmosException)
{
return(ExceptionToCosmosException.TryCreateFromException(
exceptionWithStackTrace.InnerException,
trace,
out cosmosException));
}
if (!ExceptionToCosmosException.TryCreateFromException(
exceptionWithStackTrace.InnerException,
trace,
out cosmosException))
{
return(false);
}
cosmosException = CosmosExceptionFactory.Create(
cosmosException.StatusCode,
cosmosException.Message,
exceptionWithStackTrace.StackTrace,
headers: cosmosException.Headers,
cosmosException.Trace,
cosmosException.Error,
cosmosException.InnerException);
return(true);
}
internal override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(
string containerUri,
ITrace trace,
CancellationToken cancellationToken)
{
using (ITrace childTrace = trace.StartChild("Get Container Properties", TraceComponent.Transport, Tracing.TraceLevel.Info))
{
this.ThrowIfDisposed();
CosmosDiagnosticsContext diagnosticsContext = CosmosDiagnosticsContextCore.Create(requestOptions: null);
using (diagnosticsContext.GetOverallScope())
{
ClientCollectionCache collectionCache = await this.DocumentClient.GetCollectionCacheAsync();
try
{
using (diagnosticsContext.CreateScope("ContainerCache.ResolveByNameAsync"))
{
return(await collectionCache.ResolveByNameAsync(
HttpConstants.Versions.CurrentVersion,
containerUri,
forceRefesh : false,
cancellationToken));
}
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(ex, diagnosticsContext);
}
}
}
}
public async Task <(bool isSuccess, Exception error)> TryCheckpointAsync()
{
try
{
await this.checkpointer.CheckpointPartitionAsync(this.responseMessage.Headers.ContinuationToken);
return(isSuccess : true, error : null);
}
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);
return(isSuccess : false, error : cosmosException);
}
catch (Exception exception)
{
return(isSuccess : false, error : exception);
}
}
internal override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(
string containerUri,
ITrace trace,
CancellationToken cancellationToken)
{
using (ITrace childTrace = trace.StartChild("Get Container Properties", TraceComponent.Transport, Tracing.TraceLevel.Info))
{
this.ThrowIfDisposed();
ClientCollectionCache collectionCache = await this.DocumentClient.GetCollectionCacheAsync(childTrace);
try
{
return(await collectionCache.ResolveByNameAsync(
HttpConstants.Versions.CurrentVersion,
containerUri,
forceRefesh : false,
trace : childTrace,
clientSideRequestStatistics : null,
cancellationToken : cancellationToken));
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(ex, childTrace);
}
}
}
private static CosmosException CreateFromDocumentClientException(Microsoft.Azure.Documents.DocumentClientException documentClientException)
{
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentClientException,
null);
return(cosmosException);
}
internal static ResponseMessage ToCosmosResponseMessage(this DocumentClientException documentClientException, RequestMessage requestMessage)
{
CosmosDiagnosticsContext diagnosticsContext = requestMessage?.DiagnosticsContext;
if (requestMessage != null)
{
diagnosticsContext = requestMessage.DiagnosticsContext;
if (diagnosticsContext == null)
{
throw new ArgumentNullException("Request message should contain a DiagnosticsContext");
}
}
else
{
diagnosticsContext = new CosmosDiagnosticsContextCore();
}
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentClientException,
diagnosticsContext);
PointOperationStatistics pointOperationStatistics = new PointOperationStatistics(
activityId: cosmosException.Headers.ActivityId,
statusCode: cosmosException.StatusCode,
subStatusCode: (int)SubStatusCodes.Unknown,
responseTimeUtc: DateTime.UtcNow,
requestCharge: cosmosException.Headers.RequestCharge,
errorMessage: documentClientException.ToString(),
method: requestMessage?.Method,
requestUri: requestMessage?.RequestUriString,
requestSessionToken: requestMessage?.Headers?.Session,
responseSessionToken: cosmosException.Headers.Session);
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);
}
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);
}
}
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);
}
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));
}
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 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);
}
}
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);
}
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()
});
}
/// <summary>
/// Create a <see cref="ResponseMessage"/>
/// </summary>
/// <param name="statusCode">The HttpStatusCode of the response</param>
/// <param name="requestMessage">The <see cref="Cosmos.RequestMessage"/> object</param>
/// <param name="errorMessage">The reason for failures if any.</param>
public ResponseMessage(
HttpStatusCode statusCode,
RequestMessage requestMessage = null,
string errorMessage = null)
{
if ((statusCode < 0) || ((int)statusCode > 999))
{
throw new ArgumentOutOfRangeException(nameof(statusCode));
}
this.StatusCode = statusCode;
this.RequestMessage = requestMessage;
this.Headers = new Headers();
this.Trace = requestMessage?.Trace ?? NoOpTrace.Singleton;
if (!string.IsNullOrEmpty(errorMessage))
{
this.CosmosException = CosmosExceptionFactory.Create(
statusCode,
requestMessage,
errorMessage);
}
}
/// <summary>
/// Create a <see cref="ResponseMessage"/>
/// </summary>
/// <param name="statusCode">The HttpStatusCode of the response</param>
/// <param name="requestMessage">The <see cref="Cosmos.RequestMessage"/> object</param>
/// <param name="errorMessage">The reason for failures if any.</param>
public ResponseMessage(
HttpStatusCode statusCode,
RequestMessage requestMessage = null,
string errorMessage = null)
{
if ((statusCode < 0) || ((int)statusCode > 999))
{
throw new ArgumentOutOfRangeException(nameof(statusCode));
}
this.StatusCode = statusCode;
this.RequestMessage = requestMessage;
this.Headers = new Headers();
this.DiagnosticsContext = requestMessage?.DiagnosticsContext ?? new CosmosDiagnosticsContextCore();
if (!string.IsNullOrEmpty(errorMessage))
{
this.CosmosException = CosmosExceptionFactory.Create(
statusCode,
requestMessage,
errorMessage);
}
}
/// <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="trace">The trace.</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,
ITrace trace,
CancellationToken cancellationToken)
{
try
{
ClientCollectionCache collectionCache = await this.ClientContext.DocumentClient.GetCollectionCacheAsync(trace);
return(await collectionCache.ResolveByNameAsync(
HttpConstants.Versions.CurrentVersion,
this.LinkUri,
forceRefresh,
trace : trace,
clientSideRequestStatistics : null,
cancellationToken : cancellationToken));
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(
dce: ex,
trace: trace);
}
}
