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);
}
private void Initialize()
{
if (!this.disposed)
{
if (this.serviceProvider == IntPtr.Zero)
{
lock (this.serviceProviderStateLock)
{
if (!this.disposed && this.serviceProvider == IntPtr.Zero)
{
TryCatch <IntPtr> tryCreateServiceProvider = QueryPartitionProvider.TryCreateServiceProvider(this.queryengineConfiguration);
if (tryCreateServiceProvider.Failed)
{
throw ExceptionWithStackTraceException.UnWrapMonadExcepion(tryCreateServiceProvider.Exception, NoOpTrace.Singleton);
}
this.serviceProvider = tryCreateServiceProvider.Result;
}
}
}
}
else
{
throw new ObjectDisposedException(typeof(QueryPartitionProvider).Name);
}
}
public static async Task <PartitionedQueryExecutionInfo> GetQueryPlanWithServiceInteropAsync(
CosmosQueryClient queryClient,
SqlQuerySpec sqlQuerySpec,
Documents.ResourceType resourceType,
PartitionKeyDefinition partitionKeyDefinition,
bool hasLogicalPartitionKey,
bool useSystemPrefix,
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,
resourceType,
partitionKeyDefinition,
QueryPlanRetriever.SupportedQueryFeatures,
hasLogicalPartitionKey,
useSystemPrefix,
cancellationToken);
if (!tryGetQueryPlan.Succeeded)
{
Exception originalException = ExceptionWithStackTraceException.UnWrapMonadExcepion(tryGetQueryPlan.Exception, serviceInteropTrace);
if (originalException is CosmosException)
{
throw originalException;
}
throw CosmosExceptionFactory.CreateBadRequestException(
message: originalException.Message,
headers: new Headers(),
stackTrace: tryGetQueryPlan.Exception.StackTrace,
innerException: originalException,
trace: trace);
}
return(tryGetQueryPlan.Result);
}
}
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 async Task <ResponseMessage> ReadNextInternalAsync(ITrace trace, CancellationToken cancellationToken = default)
{
if (trace == null)
{
throw new ArgumentNullException(nameof(trace));
}
TryCatch <CrossPartitionChangeFeedAsyncEnumerator> monadicEnumerator = await this.lazyMonadicEnumerator.GetValueAsync(trace, cancellationToken);
if (monadicEnumerator.Failed)
{
Exception createException = monadicEnumerator.Exception;
if (!ExceptionToCosmosException.TryCreateFromException(
createException,
trace,
out CosmosException cosmosException))
{
// Initialization issue, there are no enumerators to invoke
this.hasMoreResults = false;
throw createException;
}
return(new ResponseMessage(
cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
trace: trace));
}
CrossPartitionChangeFeedAsyncEnumerator enumerator = monadicEnumerator.Result;
enumerator.SetCancellationToken(cancellationToken);
try
{
if (!await enumerator.MoveNextAsync(trace))
{
throw new InvalidOperationException("ChangeFeed enumerator should always have a next continuation");
}
}
catch (OperationCanceledException ex) when(!(ex is CosmosOperationCanceledException))
{
throw new CosmosOperationCanceledException(ex, trace);
}
if (enumerator.Current.Failed)
{
if (!ExceptionToCosmosException.TryCreateFromException(
enumerator.Current.Exception,
trace,
out CosmosException cosmosException))
{
throw ExceptionWithStackTraceException.UnWrapMonadExcepion(enumerator.Current.Exception, trace);
}
if (!IsRetriableException(cosmosException))
{
this.hasMoreResults = false;
}
return(new ResponseMessage(
cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
trace: trace));
}
CrossFeedRangePage <Pagination.ChangeFeedPage, ChangeFeedState> crossFeedRangePage = enumerator.Current.Result;
Pagination.ChangeFeedPage changeFeedPage = crossFeedRangePage.Page;
ResponseMessage responseMessage;
if (changeFeedPage is Pagination.ChangeFeedSuccessPage changeFeedSuccessPage)
{
responseMessage = new ResponseMessage(statusCode: System.Net.HttpStatusCode.OK)
{
Content = changeFeedSuccessPage.Content
};
}
else
{
responseMessage = new ResponseMessage(statusCode: System.Net.HttpStatusCode.NotModified);
}
CrossFeedRangeState <ChangeFeedState> crossFeedRangeState = crossFeedRangePage.State;
ChangeFeedCrossFeedRangeState changeFeedCrossFeedRangeState = new ChangeFeedCrossFeedRangeState(crossFeedRangeState.Value);
string continuationToken = VersionedAndRidCheckedCompositeToken.ToCosmosElement(
new VersionedAndRidCheckedCompositeToken(
VersionedAndRidCheckedCompositeToken.Version.V2,
changeFeedCrossFeedRangeState.ToCosmosElement(),
await this.documentContainer.GetResourceIdentifierAsync(trace, cancellationToken))).ToString();
responseMessage.Headers.ContinuationToken = continuationToken;
responseMessage.Headers.RequestCharge = changeFeedPage.RequestCharge;
responseMessage.Headers.ActivityId = changeFeedPage.ActivityId;
responseMessage.Trace = trace;
return(responseMessage);
}
