private static void RunMatchRangesToContinuationTokens(
IReadOnlyDictionary <FeedRangeEpk, IPartitionedToken> expectedMapping,
IEnumerable <FeedRangeEpk> partitionKeyRanges,
IEnumerable <IPartitionedToken> partitionedTokens)
{
IReadOnlyDictionary <FeedRangeEpk, IPartitionedToken> actualMapping = PartitionMapper.MatchRangesToContinuationTokens(
partitionKeyRanges.OrderBy(x => Guid.NewGuid()).ToArray(),
partitionedTokens.OrderBy(x => Guid.NewGuid()).ToList());
ContinuationResumeLogicTests.AssertPartitionMappingAreEqual(
expectedMapping,
actualMapping);
}
private static TryCatch <CrossFeedRangeState <QueryState> > MonadicExtractState(
CosmosElement continuationToken,
IReadOnlyList <FeedRangeEpk> ranges)
{
if (continuationToken == null)
{
// Full fan out to the ranges with null continuations
CrossFeedRangeState <QueryState> fullFanOutState = new CrossFeedRangeState <QueryState>(ranges.Select(range => new FeedRangeState <QueryState>(range, (QueryState)null)).ToArray());
return(TryCatch <CrossFeedRangeState <QueryState> > .FromResult(fullFanOutState));
}
if (!(continuationToken is CosmosArray parallelContinuationTokenListRaw))
{
return(TryCatch <CrossFeedRangeState <QueryState> > .FromException(
new MalformedContinuationTokenException(
$"Invalid format for continuation token {continuationToken} for {nameof(ParallelCrossPartitionQueryPipelineStage)}")));
}
if (parallelContinuationTokenListRaw.Count == 0)
{
return(TryCatch <CrossFeedRangeState <QueryState> > .FromException(
new MalformedContinuationTokenException(
$"Invalid format for continuation token {continuationToken} for {nameof(ParallelCrossPartitionQueryPipelineStage)}")));
}
List <ParallelContinuationToken> parallelContinuationTokens = new List <ParallelContinuationToken>();
foreach (CosmosElement parallelContinuationTokenRaw in parallelContinuationTokenListRaw)
{
TryCatch <ParallelContinuationToken> tryCreateParallelContinuationToken = ParallelContinuationToken.TryCreateFromCosmosElement(parallelContinuationTokenRaw);
if (tryCreateParallelContinuationToken.Failed)
{
return(TryCatch <CrossFeedRangeState <QueryState> > .FromException(
tryCreateParallelContinuationToken.Exception));
}
parallelContinuationTokens.Add(tryCreateParallelContinuationToken.Result);
}
TryCatch <PartitionMapping <ParallelContinuationToken> > partitionMappingMonad = PartitionMapper.MonadicGetPartitionMapping(
ranges,
parallelContinuationTokens);
if (partitionMappingMonad.Failed)
{
return(TryCatch <CrossFeedRangeState <QueryState> > .FromException(
partitionMappingMonad.Exception));
}
PartitionMapping <ParallelContinuationToken> partitionMapping = partitionMappingMonad.Result;
List <FeedRangeState <QueryState> > feedRangeStates = new List <FeedRangeState <QueryState> >();
List <IReadOnlyDictionary <FeedRangeEpk, ParallelContinuationToken> > rangesToInitialize = new List <IReadOnlyDictionary <FeedRangeEpk, ParallelContinuationToken> >()
{
// Skip all the partitions left of the target range, since they have already been drained fully.
partitionMapping.TargetMapping,
partitionMapping.MappingRightOfTarget,
};
foreach (IReadOnlyDictionary <FeedRangeEpk, ParallelContinuationToken> rangeToInitalize in rangesToInitialize)
{
foreach (KeyValuePair <FeedRangeEpk, ParallelContinuationToken> kvp in rangeToInitalize)
{
FeedRangeState <QueryState> feedRangeState = new FeedRangeState <QueryState>(kvp.Key, kvp.Value?.Token != null ? new QueryState(CosmosString.Create(kvp.Value.Token)) : null);
feedRangeStates.Add(feedRangeState);
}
}
CrossFeedRangeState <QueryState> crossPartitionState = new CrossFeedRangeState <QueryState>(feedRangeStates.ToArray());
return(TryCatch <CrossFeedRangeState <QueryState> > .FromResult(crossPartitionState));
}
private static void RunTryGetInitializationInfo(
IReadOnlyDictionary <PartitionKeyRange, IPartitionedToken> expectedMappingLeftPartitions,
IReadOnlyDictionary <PartitionKeyRange, IPartitionedToken> expectedMappingTargetPartition,
IReadOnlyDictionary <PartitionKeyRange, IPartitionedToken> expectedMappingRightPartitions,
IEnumerable <PartitionKeyRange> partitionKeyRanges,
IEnumerable <IPartitionedToken> partitionedTokens)
{
TryCatch <PartitionMapping <IPartitionedToken> > tryGetInitializationInfo = PartitionMapper.MonadicGetPartitionMapping <IPartitionedToken>(
partitionKeyRanges.OrderBy(x => Guid.NewGuid()).ToArray(),
partitionedTokens.OrderBy(x => Guid.NewGuid()).ToList());
Assert.IsTrue(tryGetInitializationInfo.Succeeded);
PartitionMapping <IPartitionedToken> partitionMapping = tryGetInitializationInfo.Result;
AssertPartitionMappingAreEqual(expectedMappingLeftPartitions, partitionMapping.PartitionsLeftOfTarget);
AssertPartitionMappingAreEqual(expectedMappingTargetPartition, partitionMapping.TargetPartition);
AssertPartitionMappingAreEqual(expectedMappingRightPartitions, partitionMapping.PartitionsRightOfTarget);
}
public async Task <Result <IEnumerable <Storage> > > GetPhysicalStoragesAsync()
{
var output = new List <Storage>();
var win32DiskDrives = await GetPhysicalData(() => _componentRepo.Get <Win32_DiskDrive>());
if (!win32DiskDrives.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(win32DiskDrives.Exception));
}
var win32DiskPartitions = await GetPhysicalData(() => _componentRepo.Get <Win32_DiskPartition>());
if (!win32DiskPartitions.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(win32DiskPartitions.Exception));
}
var win32DiskDriveToDiskPartitions = await GetPhysicalData(() => _componentRepo.Get <Win32_DiskDriveToDiskPartition>());
if (!win32DiskDriveToDiskPartitions.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(win32DiskDriveToDiskPartitions.Exception));
}
var win32LogicalDiscsToPartitions = await GetPhysicalData(() => _componentRepo.Get <Win32_LogicalDiskToPartition>());
if (!win32LogicalDiscsToPartitions.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(win32LogicalDiscsToPartitions.Exception));
}
var win32LogicalDiscs = await GetPhysicalData(() => _componentRepo.Get <Win32_LogicalDisk>());
if (!win32LogicalDiscs.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(win32LogicalDiscs.Exception));
}
var msftPhysicalDiscs = await GetPhysicalData(() => _componentRepo.Get <MSFT_PhysicalDisk>());
if (!msftPhysicalDiscs.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(msftPhysicalDiscs.Exception));
}
var mappings = RelateObjects(win32DiskDriveToDiskPartitions.Output, win32LogicalDiscsToPartitions.Output);
if (!mappings.IsSuccess)
{
return(Result <IEnumerable <Storage> > .Fail(mappings.Exception));
}
try
{
foreach (var mapGroup in mappings.Output.GroupBy(x => x.DiskDrive).ToList())
{
var diskDrive = win32DiskDrives.Output.First(x => x.DeviceID == mapGroup.Key);
var msftPhysicalDisk = msftPhysicalDiscs.Output.First(x => x.Model == diskDrive.Model);
var diskPartitions = new List <Partition>();
foreach (var mapping in mapGroup)
{
var diskPartition = win32DiskPartitions.Output.First(x => x.DeviceID == mapping.DiskPartition);
var logicalDisk = win32LogicalDiscs.Output.FirstOrDefault(x => x.DeviceID == mapping.LogicalDisk);
diskPartitions.Add(PartitionMapper.From(diskPartition, logicalDisk));
}
output.Add(StorageMapper.From(diskDrive, msftPhysicalDisk, diskPartitions));
}
return(Result <IEnumerable <Storage> > .Ok(output));
}
catch (Exception e)
{
return(Result <IEnumerable <Storage> > .Fail(e));
}
}
