private async Task <SearchResult <IPackageSearchMetadata> > WaitForCompletionOrBailOutAsync(
string searchText,
IDictionary <string, Task <SearchResult <IPackageSearchMetadata> > > searchTasks,
CancellationToken cancellationToken)
{
if (searchTasks.Count == 0)
{
return(SearchResult.Empty <IPackageSearchMetadata>());
}
var aggregatedTask = Task.WhenAll(searchTasks.Values);
RefreshToken refreshToken = null;
if (aggregatedTask != await Task.WhenAny(aggregatedTask, Task.Delay(DefaultTimeout)))
{
refreshToken = new AggregatedRefreshToken
{
SearchString = searchText,
SearchTasks = searchTasks,
RetryAfter = DefaultTimeout
};
}
var partitionedTasks = searchTasks
.ToLookup(t => t.Value.Status == TaskStatus.RanToCompletion);
var completedOnly = partitionedTasks[true];
SearchResult <IPackageSearchMetadata> aggregated;
if (completedOnly.Any())
{
var results = await Task.WhenAll(completedOnly.Select(kv => kv.Value));
aggregated = await AggregateSearchResultsAsync(searchText, results);
}
else
{
aggregated = SearchResult.Empty <IPackageSearchMetadata>();
}
aggregated.RefreshToken = refreshToken;
var notCompleted = partitionedTasks[false];
if (notCompleted.Any())
{
aggregated.SourceSearchStatus
.AddRange(notCompleted
.ToDictionary(kv => kv.Key, kv => GetLoadingStatus(kv.Value.Status)));
}
// Observe the aggregate task exception to prevent an unhandled exception.
// The individual task exceptions are logged in LogError and will be reported
// in the Add Packages dialog.
var ex = aggregatedTask.Exception;
return(aggregated);
}
public MessageContext(Guid eventId, StreamContext streamContext, IDictionary <string, object> metadata)
{
EventId = eventId;
StreamContext = streamContext;
MetadataLookup = metadata
.ToLookup(keyIs => keyIs.Key, valueIs => valueIs.Value);
}
private NormalizationData(IDictionary <DataKey, DataValue> data)
{
_data = data;
_medianMedians = data.ToLookup(keyValuePair => Tuple.Create(keyValuePair.Key.SampleType, keyValuePair.Key.IsotopeLabelType),
kvp => kvp.Value)
.ToDictionary(grouping => grouping.Key,
grouping => grouping.Select(dataValue => dataValue.Median).Median());
}
/// <summary>
/// Creates a new Assertion with the supplied principal name and Assertion attributes,
/// a ValidFromDate of now, and no ValidUntilDate.
/// </summary>
/// <param name="principalName">the Principal name associated with this Assertion.</param>
/// <param name="attributes">
/// the key/value pairs for the attributes to associate with this Assertion.
/// </param>
public Assertion(string principalName, IDictionary<string, IList<string>> attributes)
{
CommonUtils.AssertNotNull(principalName, "principalName cannot be null.");
CommonUtils.AssertNotNull(attributes, "attributes cannot be null.");
this.PrincipalName = principalName;
this.ValidFromDate = DateTime.Now;
this.Attributes = attributes.ToLookup(x => x.Key, x => x.Value);
}
private async Task <SearchResult <IPackageSearchMetadata> > WaitForCompletionOrBailOutAsync(
string searchText,
IDictionary <string, Task <SearchResult <IPackageSearchMetadata> > > searchTasks,
CancellationToken cancellationToken)
{
if (searchTasks.Count == 0)
{
return(SearchResult.Empty <IPackageSearchMetadata>());
}
var aggregatedTask = Task.WhenAll(searchTasks.Values);
RefreshToken refreshToken = null;
if (aggregatedTask != await Task.WhenAny(aggregatedTask, Task.Delay(DefaultTimeout)))
{
refreshToken = new AggregatedRefreshToken
{
SearchString = searchText,
SearchTasks = searchTasks,
RetryAfter = DefaultTimeout
};
}
var partitionedTasks = searchTasks
.ToLookup(t => t.Value.Status == TaskStatus.RanToCompletion);
var completedOnly = partitionedTasks[true];
SearchResult <IPackageSearchMetadata> aggregated;
if (completedOnly.Any())
{
var results = await Task.WhenAll(completedOnly.Select(kv => kv.Value));
aggregated = await AggregateSearchResultsAsync(searchText, results);
}
else
{
aggregated = SearchResult.Empty <IPackageSearchMetadata>();
}
aggregated.RefreshToken = refreshToken;
var notCompleted = partitionedTasks[false];
if (notCompleted.Any())
{
aggregated.SourceSearchStatus
.AddRange(notCompleted
.ToDictionary(kv => kv.Key, kv => GetLoadingStatus(kv.Value.Status)));
}
return(aggregated);
}
public static Dictionary <string, string> ToHeaders(IDictionary <string, string[]> headers, bool debug)
{
var copyHeaders = new Dictionary <string, string>();
try
{
copyHeaders = headers.ToLookup(k => k.Key, k => string.Join(",", k.Value.Distinct()), StringComparer.OrdinalIgnoreCase)
.ToDictionary(k => k.Key, k => string.Join(",", k.ToList().Distinct()), StringComparer.OrdinalIgnoreCase);
}
catch (Exception inst)
{
LogDebugMessage(debug, "Error encountered while copying header");
}
return(copyHeaders);
}
public static void PrintResult(IDictionary <string, PlatformResult> dict)
{
if (dict.All(it => it.Value.Result != null))
{
if (AppVeyor)
{
PostTestResultToAppveyor(dict);
}
var result = dict.Select(it => it.Value.Result).First();
if (TeamCity)
{
Console.WriteLine("##teamcity[testStarted name='{2}.{1}.{0}' captureStandardOutput='true']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode());
}
else if (Verbose)
{
Console.Write(result.Test.Fixture.Assembly.Name + ".");
Console.Write(result.Test.Fixture.Name + ".");
}
if (TeamCity || Verbose)
{
Console.WriteLine(result.Test.Name);
}
foreach (var grpResult in dict.GroupBy(it => it.Value.Result.Kind))
{
if (Verbose || TeamCity)
{
Console.Write("{0}:", grpResult.Key);
foreach (var keyValuePair in grpResult)
{
Console.Write(" ");
Console.Write(keyValuePair.Value.Platform);
}
}
if (TeamCity)
{
switch (grpResult.Key)
{
case ResultKind.Fail:
case ResultKind.Error:
Console.WriteLine(
"##teamcity[testFailed name='{2}.{1}.{0}' message='See log or details']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode());
break;
case ResultKind.Ignore:
Console.WriteLine(
"##teamcity[testIgnored name='{2}.{1}.{0}' message='See log or details']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode());
break;
}
}
if (Verbose || TeamCity)
{
Console.WriteLine();
}
}
if (Verbose || TeamCity)
{
var span = new TimeSpan();
foreach (var r in dict.Select(it => it.Value.Result))
{
span += (r.EndTime - r.StartTime);
}
Console.WriteLine("avg time:{0}", new TimeSpan(span.Ticks / dict.Count));
}
if (Verbose || TeamCity)
{
foreach (var lup in dict.ToLookup(it => it.Value.Result.Output))
{
var name = String.Join(",", lup.Select(it => it.Value.Platform));
Console.WriteLine("{0}:", name);
Console.WriteLine(lup.Key);
}
}
if (TeamCity)
{
Console.WriteLine("##teamcity[testFinished name='{2}.{1}.{0}' duration='{3}']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode(),
(result.EndTime - result.StartTime).TotalMilliseconds);
}
else
{
if (dict.Any(it => it.Value.Result.Kind == ResultKind.Fail))
{
if (Verbose)
{
Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!");
}
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Fail))
{
Console.Write("! ");
}
else
{
Console.Write("!{0} ", dict.Where(it => it.Value.Result.Kind == ResultKind.Fail).Count());
}
}
else if (dict.Any(it => it.Value.Result.Kind == ResultKind.Error))
{
if (Verbose)
{
Console.WriteLine("EEEEEEEEEEEEEEEEEEEEEEEEE");
}
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Error))
{
Console.Write("E ");
}
else
{
Console.Write("E{0} ", dict.Where(it => it.Value.Result.Kind == ResultKind.Error).Count());
}
}
else if (dict.Any(it => it.Value.Result.Kind == ResultKind.Ignore))
{
if (Verbose)
{
Console.WriteLine("?????????????????????????");
}
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Ignore))
{
Console.Write("? ");
}
else
{
Console.Write("?{0} ", dict.Where(it => it.Value.Result.Kind == ResultKind.Ignore).Count());
}
}
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Success))
{
if (Verbose)
{
Console.WriteLine("-------------------------");
}
else
{
Console.Write(". ");
}
}
else
{
if (Verbose)
{
Console.WriteLine(".........................");
}
else if (dict.All(it => it.Value.Result.Kind == ResultKind.NoError))
{
Console.Write("_ ");
}
else
{
Console.Write("_{0} ", dict.Where(it => it.Value.Result.Kind == ResultKind.NoError).Count());
}
}
if (Verbose || ++_resultCount % 26 == 0)
{
Console.WriteLine(String.Empty);
}
}
}
}
static Entities()
{
LOOKUP = ESCAPES.ToLookup(pair => pair.Value, pair => pair.Key);
}
public static ILookup <TKey, TValue> ToLookup <TKey, TValue>(
this IDictionary <TKey, IList <TValue> > dictionary,
IEqualityComparer <TKey> comparer = null)
{
return(dictionary.ToLookup <TKey, IList <TValue>, TValue>(comparer));
}
public void Assign(IDictionary <ITemplateVariant, ProjectVariantAssignmentSettings> assignments)
{
Assign(assignments.ToLookup(x => x.Key, x => x.Value));
}
public static ILookup <TValue, TKey> Inverse <TKey, TValue>(this IDictionary <TKey, TValue> dictionary)
{
return(dictionary.ToLookup(kvp => kvp.Value, kvp => kvp.Key));
}
public static void PrintResult(IDictionary<string, PlatformResult> dict)
{
if (dict.All(it => it.Value.Result != null))
{
if (AppVeyor)
{
PostTestResultToAppveyor(dict);
}
var result = dict.Select(it => it.Value.Result).First();
if (TeamCity)
{
Console.WriteLine("##teamcity[testStarted name='{2}.{1}.{0}' captureStandardOutput='true']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode());
}
else if(Verbose)
{
Console.Write(result.Test.Fixture.Assembly.Name + ".");
Console.Write(result.Test.Fixture.Name + ".");
}
if (TeamCity || Verbose) {
Console.WriteLine (result.Test.Name);
}
foreach (var grpResult in dict.GroupBy(it => it.Value.Result.Kind))
{
if (Verbose || TeamCity) {
Console.Write ("{0}:", grpResult.Key);
foreach (var keyValuePair in grpResult) {
Console.Write (" ");
Console.Write (keyValuePair.Value.Platform);
}
}
if (TeamCity)
{
switch (grpResult.Key)
{
case ResultKind.Fail:
case ResultKind.Error:
Console.WriteLine(
"##teamcity[testFailed name='{2}.{1}.{0}' message='See log or details']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode());
break;
case ResultKind.Ignore:
Console.WriteLine(
"##teamcity[testIgnored name='{2}.{1}.{0}' message='See log or details']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode());
break;
}
}
if (Verbose || TeamCity) {
Console.WriteLine ();
}
}
if (Verbose || TeamCity) {
var span = new TimeSpan ();
foreach (var r in dict.Select(it => it.Value.Result)) {
span += (r.EndTime - r.StartTime);
}
Console.WriteLine ("avg time:{0}", new TimeSpan (span.Ticks / dict.Count));
}
if (Verbose || TeamCity) {
foreach (var lup in dict.ToLookup(it => it.Value.Result.Output)) {
var name = String.Join (",", lup.Select (it => it.Value.Platform));
Console.WriteLine ("{0}:", name);
Console.WriteLine (lup.Key);
}
}
if (TeamCity)
{
Console.WriteLine("##teamcity[testFinished name='{2}.{1}.{0}' duration='{3}']",
result.Test.Name.TeamCityEncode(),
result.Test.Fixture.Name.TeamCityEncode(),
result.Test.Fixture.Assembly.Name.TeamCityEncode(),
(result.EndTime - result.StartTime).TotalMilliseconds);
}
else
{
if (dict.Any(it => it.Value.Result.Kind == ResultKind.Fail))
{
if (Verbose)
Console.WriteLine ("!!!!!!!!!!!!!!!!!!!!!!!!!");
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Fail))
Console.Write("! ");
else
Console.Write ("!{0} ", dict.Where (it => it.Value.Result.Kind == ResultKind.Fail).Count ());
}
else if (dict.Any(it => it.Value.Result.Kind == ResultKind.Error))
{
if (Verbose)
Console.WriteLine("EEEEEEEEEEEEEEEEEEEEEEEEE");
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Error))
Console.Write("E ");
else
Console.Write ("E{0} ", dict.Where (it => it.Value.Result.Kind == ResultKind.Error).Count ());
}
else if (dict.Any(it => it.Value.Result.Kind == ResultKind.Ignore))
{
if (Verbose)
Console.WriteLine("?????????????????????????");
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Ignore))
Console.Write("? ");
else
Console.Write ("?{0} ", dict.Where (it => it.Value.Result.Kind == ResultKind.Ignore).Count ());
}
else if (dict.All(it => it.Value.Result.Kind == ResultKind.Success))
{
if (Verbose)
Console.WriteLine("-------------------------");
else
Console.Write(". ");
}
else
{
if (Verbose)
Console.WriteLine (".........................");
else if (dict.All (it => it.Value.Result.Kind == ResultKind.NoError))
Console.Write ("_ ");
else
Console.Write ("_{0} ", dict.Where (it => it.Value.Result.Kind == ResultKind.NoError).Count ());
}
if (Verbose || ++_resultCount % 26 == 0 )
Console.WriteLine(String.Empty);
}
}
}
private static Player GetTopPlayerByScore(IDictionary<Player, int> scores)
{
return GetTopPlayerByScore(scores.ToLookup(kvp => kvp.Value, kvp => kvp.Key));
}
private async Task<SearchResult<IPackageSearchMetadata>> WaitForCompletionOrBailOutAsync(
string searchText,
IDictionary<string, Task<SearchResult<IPackageSearchMetadata>>> searchTasks,
CancellationToken cancellationToken)
{
if (searchTasks.Count == 0)
{
return SearchResult.Empty<IPackageSearchMetadata>();
}
var aggregatedTask = Task.WhenAll(searchTasks.Values);
RefreshToken refreshToken = null;
if (aggregatedTask != await Task.WhenAny(aggregatedTask, Task.Delay(DefaultTimeout)))
{
refreshToken = new AggregatedRefreshToken
{
SearchString = searchText,
SearchTasks = searchTasks,
RetryAfter = DefaultTimeout
};
}
var partitionedTasks = searchTasks
.ToLookup(t => t.Value.Status == TaskStatus.RanToCompletion);
var completedOnly = partitionedTasks[true];
SearchResult<IPackageSearchMetadata> aggregated;
if (completedOnly.Any())
{
var results = await Task.WhenAll(completedOnly.Select(kv => kv.Value));
aggregated = await AggregateSearchResultsAsync(searchText, results);
}
else
{
aggregated = SearchResult.Empty<IPackageSearchMetadata>();
}
aggregated.RefreshToken = refreshToken;
var notCompleted = partitionedTasks[false];
if (notCompleted.Any())
{
aggregated.SourceSearchStatus
.AddRange(notCompleted
.ToDictionary(kv => kv.Key, kv => GetLoadingStatus(kv.Value.Status)));
}
return aggregated;
}
public ValueReferenceInverseDictionary(IDictionary <TKey, TValue> dictionary)
{
_valueReferenceToKeyLookup = dictionary.ToLookup(kv => Reference.For(kv.Value), kv => kv.Key);
}
/// <summary>
/// Stores custom parameters to be included in the validation URL.
/// </summary>
/// <param name="customParameters">custom parameters for the validation</param>
public void setCustomParameters(IDictionary<string, string> customParameters)
{
this.customParameters = customParameters.ToLookup(x => x.Key, x => x.Value);
}
private async Task <SearchResult <IPackageSearchMetadata> > WaitForCompletionOrBailOutAsync(
string searchText,
IDictionary <string, Task <SearchResult <IPackageSearchMetadata> > > searchTasks,
TelemetryState telemetryState,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (searchTasks.Count == 0)
{
return(SearchResult.Empty <IPackageSearchMetadata>());
}
var aggregatedTask = Task.WhenAll(searchTasks.Values);
RefreshToken refreshToken = null;
if (aggregatedTask != await Task.WhenAny(aggregatedTask, Task.Delay(DefaultTimeout)))
{
refreshToken = new AggregatedRefreshToken
{
TelemetryState = telemetryState,
SearchString = searchText,
SearchTasks = searchTasks,
RetryAfter = DefaultTimeout
};
}
var partitionedTasks = searchTasks
.ToLookup(t => t.Value.Status == TaskStatus.RanToCompletion);
var completedOnly = partitionedTasks[true];
SearchResult <IPackageSearchMetadata> aggregated;
IEnumerable <TimeSpan> timings = null;
var timeAggregation = new Stopwatch();
if (completedOnly.Any())
{
var results = await Task.WhenAll(completedOnly.Select(kv => kv.Value));
timings = results.Select(e => e.Duration);
timeAggregation.Start();
aggregated = await AggregateSearchResultsAsync(searchText, results, telemetryState);
timeAggregation.Stop();
}
else
{
timings = Enumerable.Empty <TimeSpan>();
aggregated = SearchResult.Empty <IPackageSearchMetadata>();
}
aggregated.OperationId = telemetryState?.OperationId;
aggregated.RefreshToken = refreshToken;
var notCompleted = partitionedTasks[false];
if (notCompleted.Any())
{
var statuses = notCompleted.ToDictionary(
kv => kv.Key,
kv => GetLoadingStatus(kv.Value.Status));
foreach (var item in statuses)
{
aggregated.SourceSearchStatus.Add(item);
}
var exceptions = notCompleted
.Where(kv => kv.Value.Exception != null)
.ToDictionary(
kv => kv.Key,
kv => (Exception)kv.Value.Exception);
foreach (var item in exceptions)
{
aggregated.SourceSearchException.Add(item);
}
}
if (_telemetryService != null &&
aggregated.SourceSearchStatus != null &&
aggregated.SourceSearchStatus.Values != null &&
telemetryState != null)
{
var loadingStatus = aggregated.SourceSearchStatus.Values.Aggregate();
if (loadingStatus != LoadingStatus.Loading &&
telemetryState.ShouldEmit)
{
telemetryState.Duration.Stop();
_telemetryService.EmitTelemetryEvent(new SearchPageTelemetryEvent(
telemetryState.OperationId,
telemetryState.PageIndex,
aggregated.Items?.Count ?? 0,
telemetryState.Duration.Elapsed,
timings,
timeAggregation.Elapsed,
loadingStatus));
}
}
return(aggregated);
}
/// <summary>
/// Converts an <see cref="IDictionary{TKey,TValue}" /> to an <see cref="ILookup{TKey,TElement}" /> by swapping the
/// keys and values.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="dictionary">The dictionary to convert.</param>
/// <returns>An <see cref="ILookup{TKey,TElement}" /> created by using the dictionary values as lookup keys and the dictionary keys as values.</returns>
public static ILookup <TValue, TKey> ToLookup <TKey, TValue>(this IDictionary <TKey, TValue> dictionary)
{
return(dictionary.ToLookup(x => x.Value, x => x.Key));
}
