public void OneTimeSetup()
{
_tmpTestProjectsExtractionPath = Path.GetFullPath(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
Directory.CreateDirectory(_tmpTestProjectsExtractionPath);
string testProjectsPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestProjects", "Miniblog.Core-master.zip");
var config = new PortingAssistantConfiguration();
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection, config);
var services = serviceCollection.BuildServiceProvider();
portingAssistantClient = services.GetService <IPortingAssistantClient>();
using (ZipArchive archive = ZipFile.Open(testProjectsPath, ZipArchiveMode.Read))
{
archive.ExtractToDirectory(_tmpTestProjectsExtractionPath);
}
var netCoreProjectPath = Path.Combine(_tmpTestProjectsExtractionPath, "Miniblog.Core-master", "Miniblog.Core.sln");
solutionAnalysisResultTask = portingAssistantClient.AnalyzeSolutionAsync(netCoreProjectPath, new AnalyzerSettings()
{
TargetFramework = "netcoreapp3.1"
});
}
public static PortingAssistantBuilder Build(PortingAssistantConfiguration configuration, Action <ILoggingBuilder> logConfiguration = null)
{
if (logConfiguration == null)
{
logConfiguration = (config) => config.AddConsole();
}
return(new PortingAssistantBuilder(configuration, logConfiguration));
}
static void Main(string[] args)
{
if (args.Length < 3)
{
throw new ArgumentException("Must provide a config file, aws profile and path");
}
var config = args[0];
var isConsole = args.Length == 4 && args[3].Equals("--console");
var outputTemplate = "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {SourceContext}: {Message:lj}{NewLine}{Exception}";
if (args.Length == 4 && !args[3].Equals("--console"))
{
// Args[3] is version number if not --console
outputTemplate = "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] (" + args[3] + ") {SourceContext}: {Message:lj}{NewLine}{Exception}";
}
Serilog.Formatting.Display.MessageTemplateTextFormatter tf =
new Serilog.Formatting.Display.MessageTemplateTextFormatter(outputTemplate, CultureInfo.InvariantCulture);
var portingAssistantSink = new PortingAssistantSink(tf);
var logConfiguration = new LoggerConfiguration().Enrich.FromLogContext()
.MinimumLevel.Debug()
.WriteTo.RollingFile(
Path.Combine(args[2], "logs", "portingAssistant-assessment-{Date}.log"),
outputTemplate: outputTemplate)
.WriteTo.Sink(portingAssistantSink);
if (isConsole)
{
logConfiguration = logConfiguration.WriteTo.Console();
}
Log.Logger = logConfiguration.CreateLogger();
var portingAssistantPortingConfiguration = JsonSerializer.Deserialize <PortingAssistantPortingConfiguration>(File.ReadAllText(config));
var configuration = new PortingAssistantConfiguration();
configuration.DataStoreSettings.HttpsEndpoint = portingAssistantPortingConfiguration.PortingAssistantConfiguration.DataStoreSettings.HttpsEndpoint;
configuration.DataStoreSettings.S3Endpoint = portingAssistantPortingConfiguration.PortingAssistantConfiguration.DataStoreSettings.S3Endpoint;
configuration.DataStoreSettings.GitHubEndpoint = portingAssistantPortingConfiguration.PortingAssistantConfiguration.DataStoreSettings.GitHubEndpoint;
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection, configuration);
try
{
var application = new Application(serviceCollection, portingAssistantSink);
application.SetupConnection(isConsole);
application.Start();
}
finally
{
Log.CloseAndFlush();
}
}
private PortingAssistantBuilder(PortingAssistantConfiguration configuration, Action <ILoggingBuilder> logConfiguration)
{
this.LogConfiguration = logConfiguration;
this.Configuration = configuration;
ConfigureServices();
var services = ServiceCollection.BuildServiceProvider();
this.PortingAssistantClient = services.GetService <IPortingAssistantClient>();
this.ReportExporter = services.GetService <IReportExporter>();
}
static private void ConfigureServices(IServiceCollection serviceCollection, PortingAssistantConfiguration config)
{
serviceCollection.AddLogging(loggingBuilder => loggingBuilder
.SetMinimumLevel(LogLevel.Debug)
.AddSerilog(logger: Log.Logger, dispose: true));
serviceCollection.AddTransient <IAssessmentService, AssessmentService>();
serviceCollection.AddTransient <IPortingService, PortingService>();
serviceCollection.AddAssessment(config);
serviceCollection.AddOptions();
}
static void Main(string[] args)
{
PortingAssistantCLI cli = new PortingAssistantCLI();
cli.HandleCommand(args);
try
{
var configuration = new PortingAssistantConfiguration();
var portingAssistantBuilder = PortingAssistantBuilder.Build(configuration, logConfig => logConfig.AddConsole());
var portingAssistantClient = portingAssistantBuilder.GetPortingAssistant();
var reportExporter = portingAssistantBuilder.GetReportExporter();
var solutionSettings = cli.IgnoreProjects != null && cli.IgnoreProjects.Count != 0 ?
new AnalyzerSettings
{
IgnoreProjects = cli.IgnoreProjects,
TargetFramework = cli.Target
} : new AnalyzerSettings
{
IgnoreProjects = new List <string>(),
TargetFramework = cli.Target
};
var analyzeResults = portingAssistantClient.AnalyzeSolutionAsync(cli.SolutionPath, solutionSettings);
analyzeResults.Wait();
if (analyzeResults.IsCompletedSuccessfully)
{
reportExporter.GenerateJsonReport(analyzeResults.Result, cli.OutputPath);
}
else
{
Console.WriteLine("err generated solution analysis report");
}
if (cli.PortingProjects != null && cli.PortingProjects.Count != 0)
{
var PortingProjectResults = analyzeResults.Result.ProjectAnalysisResults
.Where(project => cli.PortingProjects.Contains(project.ProjectName));
var FilteredRecommendedActions = PortingProjectResults
.SelectMany(project => project.PackageAnalysisResults.Values
.SelectMany(package => package.Result.Recommendations.RecommendedActions));
var PortingRequest = new PortingRequest
{
ProjectPaths = cli.PortingProjects,
SolutionPath = cli.SolutionPath,
TargetFramework = cli.Target.ToString(),
RecommendedActions = FilteredRecommendedActions.ToList()
};
var portingResults = portingAssistantClient.ApplyPortingChanges(PortingRequest);
reportExporter.GenerateJsonReport(portingResults, cli.SolutionPath, cli.OutputPath);
}
}
catch (Exception ex)
{
Console.WriteLine("error when using the tools :" + ex);
}
}
public static void AddAssessment(this IServiceCollection serviceCollection, PortingAssistantConfiguration cacheConfig)
{
serviceCollection.Configure <PortingAssistantConfiguration>(config => cacheConfig.DeepCopy(config));
serviceCollection.AddTransient <IPortingAssistantClient, PortingAssistantClient>();
serviceCollection.AddTransient <IPortingAssistantInternalNuGetCompatibilityHandler, PortingAssistantInternalNuGetCompatibilityHandler>();
serviceCollection.AddTransient <IPortingAssistantNuGetHandler, PortingAssistantNuGetHandler>();
serviceCollection.AddTransient <IPortingAssistantAnalysisHandler, PortingAssistantAnalysisHandler>();
serviceCollection.AddTransient <IPortingAssistantRecommendationHandler, PortingAssistantRecommendationHandler>();
serviceCollection.AddTransient <ICompatibilityChecker, ExternalPackagesCompatibilityChecker>();
serviceCollection.AddTransient <ICompatibilityChecker, SdkCompatibilityChecker>();
serviceCollection.AddTransient <ICompatibilityChecker, PortabilityAnalyzerCompatibilityChecker>();
serviceCollection.AddTransient <IPortingHandler, PortingHandler>();
serviceCollection.AddTransient <IPortingProjectFileHandler, PortingProjectFileHandler>();
serviceCollection.AddTransient <IHttpService, HttpService>();
serviceCollection.AddHttpClient();
}
public static void AddAssessment(this IServiceCollection serviceCollection, PortingAssistantConfiguration cacheConfig)
{
serviceCollection.Configure <PortingAssistantConfiguration>(config => cacheConfig.DeepCopy(config));
serviceCollection.AddTransient <IPortingAssistantClient, PortingAssistantClient>();
serviceCollection.AddTransient <IPortingAssistantInternalNuGetCompatibilityHandler, PortingAssistantInternalNuGetCompatibilityHandler>();
serviceCollection.AddTransient <IPortingAssistantNuGetHandler, PortingAssistantNuGetHandler>();
serviceCollection.AddTransient <IPortingAssistantAnalysisHandler, PortingAssistantAnalysisHandler>();
serviceCollection.AddTransient <IPortingAssistantRecommendationHandler, PortingAssistantRecommendationHandler>();
serviceCollection.AddTransient <ICompatibilityChecker, ExternalPackagesCompatibilityChecker>();
serviceCollection.AddTransient <ICompatibilityChecker, SdkCompatibilityChecker>();
serviceCollection.AddTransient <ICompatibilityChecker, PortabilityAnalyzerCompatibilityChecker>();
serviceCollection.AddTransient <IPortingHandler, PortingHandler>();
serviceCollection.AddTransient <IPortingProjectFileHandler, PortingProjectFileHandler>();
serviceCollection.AddTransient <IHttpService, HttpService>();
serviceCollection.AddHttpClient("s3")
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(GetRetryPolicy());
serviceCollection.AddHttpClient("github")
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(GetRetryPolicy());
}
public void OneTimeSetup()
{
_tmpTestProjectsExtractionPath = Path.GetFullPath(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
Directory.CreateDirectory(_tmpTestProjectsExtractionPath);
string testProjectsPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestProjects", "NetFrameworkExample.zip");
var config = new PortingAssistantConfiguration();
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection, config);
var services = serviceCollection.BuildServiceProvider();
portingAssistantClient = services.GetService <IPortingAssistantClient>();
using (ZipArchive archive = ZipFile.Open(testProjectsPath, ZipArchiveMode.Read))
{
archive.ExtractToDirectory(_tmpTestProjectsExtractionPath);
}
var netFrameworkProjectPath = Path.Combine(_tmpTestProjectsExtractionPath, "NetFrameworkExample", "NetFrameworkExample.sln");
solutionAnalysisResultTask = portingAssistantClient.AnalyzeSolutionAsync(netFrameworkProjectPath, new AnalyzerSettings()
{
TargetFramework = "netcoreapp3.1", ContiniousEnabled = true
});
string solutionId;
using (var sha = SHA256.Create())
{
byte[] textData = System.Text.Encoding.UTF8.GetBytes(netFrameworkProjectPath);
byte[] hash = sha.ComputeHash(textData);
solutionId = BitConverter.ToString(hash);
}
_tmpSolutionDirectory = Path.Combine(Path.GetTempPath(), solutionId);
_tmpSolutionDirectory = _tmpSolutionDirectory.Replace("-", "");
}
static private void ConfigureServices(IServiceCollection serviceCollection, PortingAssistantConfiguration config)
{
serviceCollection.AddLogging(loggingBuilder => loggingBuilder.AddConsole());
serviceCollection.AddAssessment(config);
serviceCollection.AddOptions();
}
static void Main(string[] args)
{
PortingAssistantCLI cli = new PortingAssistantCLI();
cli.HandleCommand(args);
var logConfiguration = new LoggerConfiguration().Enrich.FromLogContext()
.MinimumLevel.Debug()
.WriteTo.Console();
var assemblypath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var telemetryConfiguration = JsonSerializer.Deserialize <TelemetryConfiguration>(File.ReadAllText(Path.Combine(assemblypath, "PortingAssistantTelemetryConfig.json")));
var configuration = new PortingAssistantConfiguration();
var roamingFolder = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
var logs = Path.Combine(roamingFolder, "Porting Assistant for .NET", "logs");
var logFilePath = Path.Combine(logs, "portingAssistant-client-cli.log");
var metricsFilePath = Path.Combine(logs, "portingAssistant-client-cli.metrics");
string version = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion;
var outputTemplate = "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] (Porting Assistant Client CLI) (" + version + ") (" + cli.Tag + ") {SourceContext}: {Message:lj}{NewLine}{Exception}";
Serilog.Formatting.Display.MessageTemplateTextFormatter tf =
new Serilog.Formatting.Display.MessageTemplateTextFormatter(outputTemplate, CultureInfo.InvariantCulture);
logConfiguration.WriteTo.File(
logFilePath,
rollingInterval: RollingInterval.Infinite,
rollOnFileSizeLimit: false,
outputTemplate: outputTemplate);
Log.Logger = logConfiguration.CreateLogger();
if (cli.isSchema)
{
if (cli.schemaVersion)
{
Console.WriteLine(Common.Model.Schema.version);
}
}
if (cli.isAssess)
{
try
{
TelemetryCollector.Builder(Log.Logger, metricsFilePath);
var portingAssistantBuilder = PortingAssistantBuilder.Build(configuration, logConfig =>
logConfig.SetMinimumLevel(LogLevel.Debug)
.AddSerilog(logger: Log.Logger, dispose: true));
var portingAssistantClient = portingAssistantBuilder.GetPortingAssistant();
var reportExporter = portingAssistantBuilder.GetReportExporter();
var solutionSettings = cli.IgnoreProjects != null && cli.IgnoreProjects.Count != 0 ?
new AnalyzerSettings
{
IgnoreProjects = cli.IgnoreProjects,
TargetFramework = cli.Target
} : new AnalyzerSettings
{
IgnoreProjects = new List <string>(),
TargetFramework = cli.Target
};
var startTime = DateTime.Now;
Task <SolutionAnalysisResult> analyzeResults;
if (solutionSettings.UseGenerator)
{
analyzeResults = AnalyzeSolutionGenerator(portingAssistantClient, cli.SolutionPath, solutionSettings);
}
else
{
analyzeResults = portingAssistantClient.AnalyzeSolutionAsync(cli.SolutionPath, solutionSettings);
analyzeResults.Wait();
}
if (analyzeResults.IsCompletedSuccessfully)
{
reportExporter.GenerateJsonReport(analyzeResults.Result, cli.OutputPath);
TelemetryCollector.SolutionAssessmentCollect(analyzeResults.Result, cli.Target, "1.8.0", $"Porting Assistant Client CLI", DateTime.Now.Subtract(startTime).TotalMilliseconds, cli.Tag);
}
else
{
Log.Logger.Error("err generated solution analysis report");
}
if (cli.PortingProjects != null && cli.PortingProjects.Count != 0)
{
var PortingProjectResults = analyzeResults.Result.ProjectAnalysisResults
.Where(project => cli.PortingProjects.Contains(project.ProjectName));
var FilteredRecommendedActions = PortingProjectResults
.SelectMany(project => project.PackageAnalysisResults.Values
.Where(package =>
{
var comp = package.Result.CompatibilityResults.GetValueOrDefault(cli.Target);
return(comp.Compatibility != Compatibility.COMPATIBLE && comp.CompatibleVersions.Count != 0);
})
.SelectMany(package => package.Result.Recommendations.RecommendedActions));
var PortingRequest = new PortingRequest
{
Projects = analyzeResults.Result.SolutionDetails.Projects.Where(p => cli.PortingProjects.Contains(p.ProjectName)).ToList(),
SolutionPath = cli.SolutionPath,
TargetFramework = cli.Target.ToString(),
RecommendedActions = FilteredRecommendedActions.ToList(),
IncludeCodeFix = true
};
var portingResults = portingAssistantClient.ApplyPortingChanges(PortingRequest);
reportExporter.GenerateJsonReport(portingResults, cli.SolutionPath, cli.OutputPath);
}
UploadLogs(cli.Profile, telemetryConfiguration, logFilePath, metricsFilePath, logs);
}
catch (Exception ex)
{
Log.Logger.Error(ex, "error when using the tools :");
UploadLogs(cli.Profile, telemetryConfiguration, logFilePath, metricsFilePath, logs);
Environment.Exit(-1);
}
}
}
