private void WriteOutput(AnalyzeRequest a)
{
var sortedAnalyzeRequest = new AnalyzeRequest
{
RequestFlags = a.RequestFlags,
Dependencies = a.Dependencies
.OrderBy(t => t.Key.MemberDocId)
.ThenBy(t => t.Key.TypeDocId)
.ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection<AssemblyInfo>),
UnresolvedAssemblies = new SortedSet<string>(a.UnresolvedAssemblies, StringComparer.Ordinal),
UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary
.OrderBy(t => t.Key)
.ToDictionary(t => t.Key, t => new SortedSet<string>(t.Value) as ICollection<string>),
UserAssemblies = new SortedSet<AssemblyInfo>(a.UserAssemblies),
AssembliesWithErrors = new SortedSet<string>(a.AssembliesWithErrors, StringComparer.Ordinal),
Targets = new SortedSet<string>(a.Targets, StringComparer.Ordinal),
ApplicationName = a.ApplicationName,
Version = a.Version,
BreakingChangesToSuppress = new SortedSet<string>(a.BreakingChangesToSuppress ?? Enumerable.Empty<string>(), StringComparer.Ordinal),
AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity)
};
var tmp = $"{Path.GetTempFileName()}.json";
using (var ms = new MemoryStream(sortedAnalyzeRequest.Serialize()))
using (var fs = File.OpenWrite(tmp))
{
ms.CopyTo(fs);
}
Process.Start(tmp);
}
public async Task<ServiceResponse<byte[]>> SendAnalysisAsync(AnalyzeRequest a, string format)
{
var formatInformation = await GetResultFormat(format);
var sendAnalysis = _endpoint + Endpoints.Analyze;
return await _client.CallAsync(HttpMethod.Post, sendAnalysis, a, formatInformation);
}
public AnalyzeResponse AnalyzeRequest(AnalyzeRequest request, string submissionId)
{
// Get the list of targets we should consider in the analysis
var targets = _targetNameParser
.MapTargetsToExplicitVersions(request.Targets.SelectMany(_targetMapper.GetNames))
.OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase)
.ToList();
var userAssemblies = new HashSet<string>(request.UserAssemblies.Select(a => a.AssemblyIdentity), StringComparer.OrdinalIgnoreCase);
var notInAnyTarget = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowNonPortableApis)
? _analysisEngine.FindMembersNotInTargets(targets, userAssemblies, request.Dependencies)
: new List<MemberInfo>();
var unresolvedAssemblies = request.UnresolvedAssembliesDictionary != null
? request.UnresolvedAssembliesDictionary.Keys
: request.UnresolvedAssemblies;
var missingUserAssemblies = _analysisEngine.FindUnreferencedAssemblies(unresolvedAssemblies, request.UserAssemblies).ToList();
var breakingChangeSkippedAssemblies = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges)
? _analysisEngine.FindBreakingChangeSkippedAssemblies(targets, request.UserAssemblies, request.AssembliesToIgnore).ToList()
: new List<AssemblyInfo>();
var breakingChanges = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges)
? _analysisEngine.FindBreakingChanges(targets, request.Dependencies, breakingChangeSkippedAssemblies, request.BreakingChangesToSuppress, userAssemblies, request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowRetargettingIssues)).ToList()
: new List<BreakingChangeDependency>();
var reportingResult = _reportGenerator.ComputeReport(
targets,
submissionId,
request.RequestFlags,
request.Dependencies,
notInAnyTarget,
request.UnresolvedAssembliesDictionary,
missingUserAssemblies,
request.AssembliesWithErrors);
return new AnalyzeResponse
{
CatalogLastUpdated = _analysisEngine.CatalogLastUpdated,
ApplicationName = request.ApplicationName,
MissingDependencies = notInAnyTarget,
UnresolvedUserAssemblies = missingUserAssemblies,
Targets = targets,
ReportingResult = reportingResult,
SubmissionId = submissionId,
BreakingChanges = breakingChanges,
BreakingChangeSkippedAssemblies = breakingChangeSkippedAssemblies
};
}
/// <summary>
/// Gets the Portability report for the request.
/// </summary>
/// <returns>An array of bytes corresponding to the report.</returns>
private async Task<byte[]> GetResultFromServiceAsync(AnalyzeRequest request, string format)
{
using (var progressTask = _progressReport.StartTask(LocalizedStrings.SendingDataToService))
{
try
{
var response = await _apiPortService.SendAnalysisAsync(request, format);
CheckEndpointStatus(response.Headers.Status);
return response.Response;
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
private async Task<ServiceResponse<AnalyzeResponse>> RetrieveResultAsync(AnalyzeRequest request)
{
using (var progressTask = _progressReport.StartTask(LocalizedStrings.SendingDataToService))
{
try
{
return await _apiPortService.SendAnalysisAsync(request);
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
/// <summary>
/// Gets the Portability of an application as a ReportingResult.
/// </summary>
/// <returns>Set of APIs/assemblies that are not portable/missing.</returns>
private async Task<ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo)
{
var fullResponse = await RetrieveResultAsync(request);
CheckEndpointStatus(fullResponse.Headers.Status);
using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport))
{
try
{
var response = fullResponse.Response;
return _reportGenerator.ComputeReport(
response.Targets,
response.SubmissionId,
request.RequestFlags,
dependencyInfo?.Dependencies,
response.MissingDependencies,
dependencyInfo?.UnresolvedAssemblies,
response.UnresolvedUserAssemblies,
dependencyInfo?.AssembliesWithErrors
);
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
/// <summary>
/// Gets the Portability report for the request.
/// </summary>
/// <returns>An array of bytes corresponding to the report.</returns>
private async Task<byte[]> GetResultFromServiceAsync(AnalyzeRequest request, string format)
{
var response = await _apiPortService.SendAnalysisAsync(request, format);
CheckEndpointStatus(response.Headers.Status);
return response.Response;
}
public Task<ServiceResponse<byte[]>> SendAnalysisAsync(AnalyzeRequest a, string format)
{
var sortedAnalyzeRequest = new AnalyzeRequest
{
RequestFlags = a.RequestFlags,
Dependencies = a.Dependencies
.OrderBy(t => t.Key.MemberDocId)
.ThenBy(t => t.Key.TypeDocId)
.ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection<AssemblyInfo>),
UnresolvedAssemblies = new SortedSet<string>(a.UnresolvedAssemblies, StringComparer.Ordinal),
UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary
.OrderBy(t => t.Key)
.ToDictionary(t => t.Key, t => new SortedSet<string>(t.Value) as ICollection<string>),
UserAssemblies = new SortedSet<AssemblyInfo>(a.UserAssemblies),
AssembliesWithErrors = new SortedSet<string>(a.AssembliesWithErrors, StringComparer.Ordinal),
Targets = new SortedSet<string>(a.Targets, StringComparer.Ordinal),
ApplicationName = a.ApplicationName,
Version = a.Version,
BreakingChangesToSuppress = new SortedSet<string>(a.BreakingChangesToSuppress ?? Enumerable.Empty<string>(), StringComparer.Ordinal),
AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity)
};
var result = sortedAnalyzeRequest.Serialize();
return Task.FromResult(ServiceResponse.Create(result));
}
public Task<ServiceResponse<AnalyzeResponse>> SendAnalysisAsync(AnalyzeRequest a)
{
_progress.ReportIssue(LocalizedStrings.FileOutputServiceNotSupported);
return Task.FromResult(new ServiceResponse<AnalyzeResponse>(new AnalyzeResponse()));
}
public async Task<ServiceResponse<AnalyzeResponse>> SendAnalysisAsync(AnalyzeRequest a)
{
return await _client.CallAsync<AnalyzeRequest, AnalyzeResponse>(HttpMethod.Post, Endpoints.Analyze, a);
}
private ReportingResult GetReportingResult(AnalyzeRequest request, AnalyzeResponse response, IDependencyInfo dependencyInfo)
{
if (response == null)
{
return null;
}
using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport))
{
try
{
return _reportGenerator.ComputeReport(
response.Targets,
response.SubmissionId,
request.RequestFlags,
dependencyInfo?.Dependencies,
response.MissingDependencies,
dependencyInfo?.UnresolvedAssemblies,
response.UnresolvedUserAssemblies,
dependencyInfo?.AssembliesWithErrors
);
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
/// <summary>
/// Gets the Portability of an application as a ReportingResult.
/// </summary>
/// <returns>Set of APIs/assemblies that are not portable/missing.</returns>
private async Task<ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo)
{
var fullResponse = await RetrieveResultAsync(request);
CheckEndpointStatus(fullResponse.Headers.Status);
return GetReportingResult(request, fullResponse.Response, dependencyInfo);
}
public async Task<ServiceResponse<IEnumerable<ReportingResultWithFormat>>> SendAnalysisAsync(AnalyzeRequest a, IEnumerable<string> format)
{
var formatInformation = await GetResultFormat(format);
return await _client.CallAsync(HttpMethod.Post, Endpoints.Analyze, a, formatInformation);
}
public Task<ServiceResponse<byte[]>> SendAnalysisAsync(AnalyzeRequest a, string format)
{
WriteOutput(a);
return Task.FromResult(new ServiceResponse<byte[]>(new byte[] { }));
}
public Task<ServiceResponse<AnalyzeResponse>> SendAnalysisAsync(AnalyzeRequest a)
{
WriteOutput(a);
return Task.FromResult(new ServiceResponse<AnalyzeResponse>(new AnalyzeResponse()));
}
public Task<ServiceResponse<IEnumerable<ReportingResultWithFormat>>> SendAnalysisAsync(AnalyzeRequest a, IEnumerable<string> formats)
{
var result = formats.Select(f => new ReportingResultWithFormat
{
Data = SendAnalysisAsync(a, f),
Format = f
});
return Task.FromResult(new ServiceResponse<IEnumerable<ReportingResultWithFormat>>(result.ToList()));
}
