private PartitionKeyRange TryResolveSinglePartitionCollection(
DocumentServiceRequest request,
ContainerProperties collection,
CollectionRoutingMap routingMap,
bool collectionCacheIsUptoDate)
{
// Neither partitionkey nor partitionkeyrangeid is specified.
// Three options here:
// * This is non-partitioned collection and old client SDK which doesn't send partition key. In
// this case there's single entry in routing map. But can be multiple entries if before that
// existed partitioned collection with same name.
// * This is partitioned collection and old client SDK which doesn't send partition key.
// In this case there can be multiple ranges in routing map.
// * This is partitioned collection and this is custom written REST sdk, which has a bug and doesn't send
// partition key.
// We cannot know for sure whether this is partitioned collection or not, because
// partition key definition cache can be outdated.
// So we route request to the first partition. If this is non-partitioned collection - request will succeed.
// If it is partitioned collection - backend will return bad request as partition key header is required in this case.
if (routingMap.OrderedPartitionKeyRanges.Count == 1)
{
return(routingMap.OrderedPartitionKeyRanges.Single());
}
if (collectionCacheIsUptoDate)
{
// If the current collection is user-partitioned collection
if (collection.PartitionKey.Paths.Count >= 1 &&
!collection.PartitionKey.IsSystemKey.GetValueOrDefault(false))
{
throw new BadRequestException(RMResources.MissingPartitionKeyValue)
{
ResourceAddress = request.ResourceAddress
};
}
else if (routingMap.OrderedPartitionKeyRanges.Count > 1)
{
// With migrated-fixed-collection, it is possible to have multiple partition key ranges
// due to parallel usage of V3 SDK and a possible storage or throughput split
// The current client might be legacy and not aware of this.
// In such case route the request to the first partition
return(AddressResolver.TryResolveServerPartitionByPartitionKey(
request,
"[]", // This corresponds to first partition
collectionCacheIsUptoDate,
collection,
routingMap));
}
else
{
// routingMap.OrderedPartitionKeyRanges.Count == 0
// Should never come here.
DefaultTrace.TraceCritical(
"No Partition Key ranges present for the collection {0}", collection.ResourceId);
throw new InternalServerErrorException(RMResources.InternalServerError)
{
ResourceAddress = request.ResourceAddress
};
}
}
else
{
return(null);
}
}
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));
}
private async Task <ResolutionResult> TryResolveServerPartitionAsync(
DocumentServiceRequest request,
ContainerProperties collection,
CollectionRoutingMap routingMap,
bool collectionCacheIsUptodate,
bool collectionRoutingMapCacheIsUptodate,
bool forceRefreshPartitionAddresses,
CancellationToken cancellationToken)
{
// Check if this request partitionkeyrange-aware routing logic. We cannot retry here in this case
// and need to bubble up errors.
if (request.PartitionKeyRangeIdentity != null)
{
return(await this.TryResolveServerPartitionByPartitionKeyRangeIdAsync(
request,
collection,
routingMap,
collectionCacheIsUptodate,
collectionRoutingMapCacheIsUptodate,
forceRefreshPartitionAddresses,
cancellationToken));
}
if (!request.ResourceType.IsPartitioned() &&
!(request.ResourceType == ResourceType.StoredProcedure && request.OperationType == OperationType.ExecuteJavaScript) &&
// Collection head is sent internally for strong consistency given routing hints from original requst, which is for partitioned resource.
!(request.ResourceType == ResourceType.Collection && request.OperationType == OperationType.Head))
{
DefaultTrace.TraceCritical(
"Shouldn't come here for non partitioned resources. resourceType : {0}, operationtype:{1}, resourceaddress:{2}",
request.ResourceType,
request.OperationType,
request.ResourceAddress);
throw new InternalServerErrorException(RMResources.InternalServerError)
{
ResourceAddress = request.ResourceAddress
};
}
PartitionKeyRange range;
string partitionKeyString = request.Headers[HttpConstants.HttpHeaders.PartitionKey];
object effectivePartitionKeyStringObject = null;
if (partitionKeyString != null)
{
range = AddressResolver.TryResolveServerPartitionByPartitionKey(
request,
partitionKeyString,
collectionCacheIsUptodate,
collection,
routingMap);
}
else if (request.Properties != null && request.Properties.TryGetValue(
WFConstants.BackendHeaders.EffectivePartitionKeyString,
out effectivePartitionKeyStringObject))
{
// Allow EPK only for partitioned collection (excluding migrated fixed collections)
if (!collection.HasPartitionKey || collection.PartitionKey.IsSystemKey.GetValueOrDefault(false))
{
throw new ArgumentOutOfRangeException(nameof(collection));
}
string effectivePartitionKeyString = effectivePartitionKeyStringObject as string;
if (string.IsNullOrEmpty(effectivePartitionKeyString))
{
throw new ArgumentOutOfRangeException(nameof(effectivePartitionKeyString));
}
range = routingMap.GetRangeByEffectivePartitionKey(effectivePartitionKeyString);
}
else
{
range = this.TryResolveSinglePartitionCollection(request, collection, routingMap, collectionCacheIsUptodate);
}
if (range == null)
{
// Collection cache or routing map cache is potentially outdated. Return null -
// upper logic will refresh cache and retry.
return(null);
}
ServiceIdentity serviceIdentity = routingMap.TryGetInfoByPartitionKeyRangeId(range.Id);
PartitionAddressInformation addresses = await this.addressCache.TryGetAddressesAsync(
request,
new PartitionKeyRangeIdentity(collection.ResourceId, range.Id),
serviceIdentity,
forceRefreshPartitionAddresses,
cancellationToken);
if (addresses == null)
{
DefaultTrace.TraceVerbose(
"Could not resolve addresses for identity {0}/{1}. Potentially collection cache or routing map cache is outdated. Return null - upper logic will refresh and retry. ",
new PartitionKeyRangeIdentity(collection.ResourceId, range.Id),
serviceIdentity);
return(null);
}
return(new ResolutionResult(range, addresses, serviceIdentity));
}
