internal override async Task <ContainerProperties> GetCachedContainerPropertiesAsync(
string containerUri,
CancellationToken cancellationToken = default(CancellationToken))
{
ClientCollectionCache collectionCache = await this.DocumentClient.GetCollectionCacheAsync();
try
{
return(await collectionCache.ResolveByNameAsync(
HttpConstants.Versions.CurrentVersion,
containerUri,
cancellationToken));
}
catch (DocumentClientException ex)
{
throw new CosmosException(ex.ToCosmosResponseMessage(null), ex.Message, ex.Error);
}
}
/// <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 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);
}
}
/// <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);
}
}
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,
cancellationToken));
}
catch (DocumentClientException ex)
{
throw CosmosExceptionFactory.Create(ex, childTrace);
}
}
}
public RenameCollectionAwareClientRetryPolicy(ISessionContainer sessionContainer, ClientCollectionCache collectionCache, IDocumentClientRetryPolicy retryPolicy)
{
this.retryPolicy = retryPolicy;
this.sessionContainer = sessionContainer;
this.collectionCache = collectionCache;
this.request = null;
}
/// <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 async Task <ContainerProperties> GetCachedContainerPropertiesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
ClientCollectionCache collectionCache = await this.ClientContext.DocumentClient.GetCollectionCacheAsync();
return(await collectionCache.ResolveByNameAsync(HttpConstants.Versions.CurrentVersion, this.LinkUri.OriginalString, cancellationToken));
}
private static async Task <Tuple <bool, PartitionKeyRange> > TryResolvePartitionKeyRangeAsync(DocumentServiceRequest request,
ISessionContainer sessionContainer,
PartitionKeyRangeCache partitionKeyRangeCache,
ClientCollectionCache clientCollectionCache,
bool refreshCache)
{
if (refreshCache)
{
request.ForceMasterRefresh = true;
request.ForceNameCacheRefresh = true;
}
PartitionKeyRange partitonKeyRange = null;
ContainerProperties collection = await clientCollectionCache.ResolveCollectionAsync(request, CancellationToken.None, NoOpTrace.Singleton);
string partitionKeyString = request.Headers[HttpConstants.HttpHeaders.PartitionKey];
if (partitionKeyString != null)
{
CollectionRoutingMap collectionRoutingMap = await partitionKeyRangeCache.TryLookupAsync(collectionRid : collection.ResourceId,
previousValue : null,
request : request,
cancellationToken : CancellationToken.None,
NoOpTrace.Singleton);
if (refreshCache && collectionRoutingMap != null)
{
collectionRoutingMap = await partitionKeyRangeCache.TryLookupAsync(collectionRid : collection.ResourceId,
previousValue : collectionRoutingMap,
request : request,
cancellationToken : CancellationToken.None,
NoOpTrace.Singleton);
}
partitonKeyRange = AddressResolver.TryResolveServerPartitionByPartitionKey(request: request,
partitionKeyString: partitionKeyString,
collectionCacheUptoDate: false,
collection: collection,
routingMap: collectionRoutingMap);
}
else if (request.PartitionKeyRangeIdentity != null)
{
PartitionKeyRangeIdentity partitionKeyRangeId = request.PartitionKeyRangeIdentity;
partitonKeyRange = await partitionKeyRangeCache.TryGetPartitionKeyRangeByIdAsync(collection.ResourceId,
partitionKeyRangeId.ToString(),
NoOpTrace.Singleton,
refreshCache);
}
if (partitonKeyRange == null)
{
if (refreshCache)
{
return(new Tuple <bool, PartitionKeyRange>(false, null));
}
// need to refresh cache. Maybe split happened.
return(await GatewayStoreModel.TryResolvePartitionKeyRangeAsync(request : request,
sessionContainer : sessionContainer,
partitionKeyRangeCache : partitionKeyRangeCache,
clientCollectionCache : clientCollectionCache,
refreshCache : true));
}
return(new Tuple <bool, PartitionKeyRange>(true, partitonKeyRange));
}
internal static async Task <Tuple <bool, string> > TryResolveSessionTokenAsync(DocumentServiceRequest request,
ISessionContainer sessionContainer,
PartitionKeyRangeCache partitionKeyRangeCache,
ClientCollectionCache clientCollectionCache)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (sessionContainer == null)
{
throw new ArgumentNullException(nameof(sessionContainer));
}
if (partitionKeyRangeCache == null)
{
throw new ArgumentNullException(nameof(partitionKeyRangeCache));
}
if (clientCollectionCache == null)
{
throw new ArgumentNullException(nameof(clientCollectionCache));
}
if (request.ResourceType.IsPartitioned())
{
(bool isSuccess, PartitionKeyRange partitionKeyRange) = await TryResolvePartitionKeyRangeAsync(request : request,
sessionContainer : sessionContainer,
partitionKeyRangeCache : partitionKeyRangeCache,
clientCollectionCache : clientCollectionCache,
refreshCache : false);
if (isSuccess && sessionContainer is SessionContainer gatewaySessionContainer)
{
request.RequestContext.ResolvedPartitionKeyRange = partitionKeyRange;
string localSessionToken = gatewaySessionContainer.ResolvePartitionLocalSessionTokenForGateway(request, partitionKeyRange.Id);
if (!string.IsNullOrEmpty(localSessionToken))
{
return(new Tuple <bool, string>(true, localSessionToken));
}
}
}
return(new Tuple <bool, string>(false, null));
}
public void SetCaches(PartitionKeyRangeCache partitionKeyRangeCache,
ClientCollectionCache clientCollectionCache)
{
this.clientCollectionCache = clientCollectionCache;
this.partitionKeyRangeCache = partitionKeyRangeCache;
}