private void AddWCFReferences(PortCoreConfiguration projectConfiguration)
{
ProjectType projectType = projectConfiguration.ProjectType;
if (projectType == ProjectType.WCFCodeBasedService || projectType == ProjectType.WCFConfigBasedService || projectType == ProjectType.WCFServiceLibrary)
{
projectConfiguration.AdditionalReferences.AddRange(WCFConstants.CoreWCFRules);
if (projectType == ProjectType.WCFConfigBasedService)
{
projectConfiguration.AdditionalReferences.Add(WCFConstants.CoreWCFConfigBasedProjectRule);
}
else if (projectType == ProjectType.WCFCodeBasedService)
{
projectConfiguration.AdditionalReferences.Add(WCFConstants.CoreWCFCodeBasedProjectRule);
}
else if (projectType == ProjectType.WCFServiceLibrary)
{
projectConfiguration.AdditionalReferences.Add(WCFConstants.CoreWCFServiceLibraryProjectRule);
}
}
if (projectType == ProjectType.WCFClient)
{
projectConfiguration.AdditionalReferences.Add(WCFConstants.WCFClientProjectRule);
}
}
private Dictionary <string, ProjectActions> AnalyzeActions(List <string> projects, string targetFramework, List <AnalyzerResult> analyzerResults, string pathToSolution)
{
List <PortCoreConfiguration> configs = new List <PortCoreConfiguration>();
var anaylyzedProjects = projects.Where(p =>
{
var project = analyzerResults.Find((a) => a.ProjectResult?.ProjectFilePath != null &&
a.ProjectResult.ProjectFilePath.Equals(p));
return(project != null);
}).ToList();
foreach (var proj in anaylyzedProjects)
{
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = proj,
UseDefaultRules = true,
TargetVersions = new List <string> {
targetFramework
},
};
configs.Add(projectConfiguration);
}
var solutionPort = new SolutionPort(pathToSolution, analyzerResults, configs, _logger);
return(solutionPort.AnalysisRun().ToDictionary(cd => cd.Key, cd => cd.Value));
}
public void OneTimeSetup()
{
var workingDirectory = Environment.CurrentDirectory;
_testProjectPath = Directory.GetParent(workingDirectory).Parent.Parent.FullName;
var codeAnalyzer = CreateDefaultCodeAnalyzer();
// Get analyzer results from codelyzer (syntax trees, semantic models, package references, project references, etc)
var analyzerResult = codeAnalyzer.AnalyzeProject(DownloadTestProjectsFixture.EShopLegacyWebFormsProjectPath).Result;
var ctaArgs = new[]
{
"-p", DownloadTestProjectsFixture.EShopLegacyWebFormsProjectPath, // can hardcode for local use
"-v", "net5.0", // set the Target Framework version
"-d", "true", // use the default rules files (these will get downloaded from S3 and will tell CTA which packages to add to the new .csproj file)
"-m", "false", // this is the "mock run" flag. Setting it to false means rules will be applied if we do a full port.
};
// Handle argument assignment
PortCoreRulesCli cli = new PortCoreRulesCli();
cli.HandleCommand(ctaArgs);
if (cli.DefaultRules)
{
// Since we're using default rules, we want to specify where to find those rules (once they are downloaded)
cli.RulesDir = Constants.RulesDefaultPath;
}
var packageReferences = new Dictionary <string, Tuple <string, string> >
{
{ "Autofac", new Tuple <string, string>("4.9.1.0", "4.9.3") },
{ "EntityFramework", new Tuple <string, string>("6.0.0.0", "6.4.4") },
{ "log4net", new Tuple <string, string>("2.0.8.0", "2.0.12") },
{ "Microsoft.Extensions.Logging.Log4Net.AspNetCore", new Tuple <string, string>("1.0.0", "2.2.12") }
};
// Create a configuration object using the CLI and other arbitrary values
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = cli.FilePath,
RulesDir = cli.RulesDir,
IsMockRun = cli.IsMockRun,
UseDefaultRules = cli.DefaultRules,
PackageReferences = packageReferences,
PortCode = false,
PortProject = true,
TargetVersions = new List <string> {
cli.Version
}
};
var projectRewriter = new ProjectRewriter(analyzerResult, projectConfiguration);
ProjectResult projectResult = projectRewriter.Initialize();
_webFormsProjectAnalyzer = new ProjectAnalyzer(_testProjectPath, analyzerResult, projectConfiguration, projectResult);
_blazorWorkspaceManager = new WorkspaceManagerService();
}
public ProjectResult RunProject(AnalyzerResult analyzerResult, PortCoreConfiguration portCoreConfiguration)
{
var projectPort = new ProjectPort(analyzerResult, portCoreConfiguration, this);
var projectAnalysisResult = projectPort.AnalysisRun();
var projectResult = projectPort.Run();
_portSolutionResult.References.UnionWith(projectPort.ProjectReferences);
AppendProjectResult(projectAnalysisResult, projectResult, analyzerResult, projectPort.ProjectTypeFeatureResults);
return(projectResult);
}
static void Main(string[] args)
{
try
{
PortCoreRulesCli cli = new PortCoreRulesCli();
cli.HandleCommand(args);
Console.WriteLine(cli.FilePath);
/* 1. Logger object */
var loggerFactory = LoggerFactory.Create(builder => builder.SetMinimumLevel(LogLevel.Debug).AddConsole());
LogHelper.Logger = loggerFactory.CreateLogger("Translator");
if (string.IsNullOrEmpty(cli.RulesPath))
{
//TODO : Change the hard coded path to a constant
cli.RulesPath = Config.Constants.RulesDefaultPath;
}
string solutionDir = Directory.GetParent(cli.FilePath).FullName;
var projectFiles = Directory.EnumerateFiles(solutionDir, "*.csproj", SearchOption.AllDirectories);
List <PortCoreConfiguration> configs = new List <PortCoreConfiguration>();
foreach (var proj in projectFiles)
{
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = proj,
RulesPath = cli.RulesPath,
IsMockRun = cli.IsMockRun,
UseDefaultRules = cli.DefaultRules,
TargetVersions = new List <string> {
cli.Version
}
};
configs.Add(projectConfiguration);
}
//Solution Rewriter:
SolutionPort solutionPort = new SolutionPort(cli.FilePath, configs);
var s = solutionPort.AnalysisRun();
foreach (var k in s.Keys)
{
Console.WriteLine(k);
Console.WriteLine(s[k].ToString());
}
var portSolutionResult = solutionPort.Run();
}
catch (Exception ex)
{
LogHelper.LogError("Error while running solution rewriter: {0}", ex.Message);
}
}
public async Task TestWebApiWithReferencesUsingGenerator(string version)
{
var solutionPath = CopySolutionFolderToTemp("WebApiWithReferences.sln", tempDir);
AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp)
{
ExportSettings =
{
GenerateJsonOutput = false,
OutputPath = @"/tmp/UnitTests"
},
MetaDataSettings =
{
LiteralExpressions = true,
MethodInvocations = true,
Annotations = true,
DeclarationNodes = true,
LocationData = false,
ReferenceData = true,
LoadBuildData = true,
ElementAccess = true,
MemberAccess = true
}
};
CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance);
SolutionPort solutionPort = new SolutionPort(solutionPath);
var resultEnumerator = analyzer.AnalyzeSolutionGeneratorAsync(solutionPath).GetAsyncEnumerator();
while (await resultEnumerator.MoveNextAsync())
{
using var result = resultEnumerator.Current;
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
SolutionPath = solutionPath,
ProjectPath = result.ProjectResult.ProjectFilePath,
IsMockRun = false,
UseDefaultRules = true,
PortCode = true,
PortProject = true,
TargetVersions = new List <string> {
version
}
};
solutionPort.RunProject(result, projectConfiguration);
}
var portSolutionResult = solutionPort.GenerateResults();
var testSolutionResult = GenerateSolutionResult(solutionPath, solutionPort.GetAnalysisResult(), portSolutionResult);
ValidateWebApiWithReferences(testSolutionResult);
}
public ProjectPort(AnalyzerResult analyzerResult, PortCoreConfiguration projectConfiguration, SolutionPort solutionPort, ILogger logger = null)
{
if (logger != null)
{
LogHelper.Logger = logger;
}
_solutionPort = solutionPort;
ProjectReferences = new HashSet <string>()
{
Constants.ProjectRecommendationFile
};
InitProjectRewriter(analyzerResult, projectConfiguration);
}
public async IAsyncEnumerable <ProjectAnalysisResult> AnalyzeSolutionGeneratorAsync(string solutionFilename, List <string> projects, string targetFramework = "netcoreapp3.1")
{
var configuration = GetAnalyzerConfiguration();
var analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, _logger);
var resultEnumerator = analyzer.AnalyzeSolutionGeneratorAsync(solutionFilename).GetAsyncEnumerator();
try
{
SolutionPort solutionPort = new SolutionPort(solutionFilename);
while (await resultEnumerator.MoveNextAsync().ConfigureAwait(false))
{
var result = resultEnumerator.Current;
var projectPath = result?.ProjectResult?.ProjectFilePath;
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = projectPath,
UseDefaultRules = true,
TargetVersions = new List <string> {
targetFramework
},
PortCode = false,
PortProject = false
};
var projectResult = solutionPort.RunProject(result, projectConfiguration);
var analysisActions = AnalyzeActions(new List <string> {
projectPath
}, targetFramework, new List <AnalyzerResult> {
result
}, solutionFilename);
var analysisResult = AnalyzeProject(projectPath, solutionFilename, new List <AnalyzerResult> {
result
}, analysisActions, isIncremental: false, targetFramework);
result.Dispose();
yield return(analysisResult);
}
}
finally
{
await resultEnumerator.DisposeAsync();
}
}
private void InitRules(PortCoreConfiguration projectConfiguration, AnalyzerResult analyzerResult)
{
using var projectTypeFeatureDetector = new FeatureDetector();
ProjectTypeFeatureResults = projectTypeFeatureDetector.DetectFeaturesInProject(analyzerResult);
projectConfiguration.ProjectType = _solutionPort.GetProjectType(ProjectTypeFeatureResults);
if (projectConfiguration.UseDefaultRules)
{
//If a rules dir was provided, copy files from that dir into the rules folder
if (!string.IsNullOrEmpty(projectConfiguration.RulesDir))
{
_solutionPort.CopyOverrideRules(projectConfiguration.RulesDir);
}
projectConfiguration.RulesDir = Constants.RulesDefaultPath;
var projectResult = analyzerResult.ProjectResult;
projectResult?.SourceFileResults?.SelectMany(s => s.References)?.Select(r => r.Namespace).Distinct().ToList().ForEach(currentReference =>
{
if (currentReference != null && !ProjectReferences.Contains(currentReference))
{
ProjectReferences.Add(currentReference);
}
});
projectResult?.SourceFileResults?.SelectMany(s => s.Children.OfType <UsingDirective>())?.Select(u => u.Identifier).Distinct().ToList().ForEach(currentReference =>
{
if (currentReference != null && !ProjectReferences.Contains(currentReference))
{
ProjectReferences.Add(currentReference);
}
});
ProjectReferences.Add(Constants.ProjectRecommendationFile);
}
_solutionPort.DownloadRecommendationFiles(ProjectReferences);
}
private List <ProjectResult> AnalyzeActions(List <string> projects, string targetFramework, List <AnalyzerResult> analyzerResults, string pathToSolution)
{
_logger.LogInformation("Memory Consumption before AnalyzeActions: ");
MemoryUtils.LogMemoryConsumption(_logger);
List <PortCoreConfiguration> configs = new List <PortCoreConfiguration>();
var anaylyzedProjects = projects.Where(p =>
{
var project = analyzerResults.Find((a) => a.ProjectResult?.ProjectFilePath != null &&
a.ProjectResult.ProjectFilePath.Equals(p));
return(project != null);
}).ToList();
foreach (var proj in anaylyzedProjects)
{
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = proj,
UseDefaultRules = true,
TargetVersions = new List <string> {
targetFramework
},
PortCode = false,
PortProject = false
};
configs.Add(projectConfiguration);
}
var solutionPort = new SolutionPort(pathToSolution, analyzerResults, configs, _logger);
var projectResults = solutionPort.Run().ProjectResults.ToList();
_logger.LogInformation("Memory Consumption after AnalyzeActions: ");
MemoryUtils.LogMemoryConsumption(_logger);
return(projectResults);
}
private List <IDEFileActions> AnalyzeFileActionsIncremental(string project, RootNodes rootNodes, string targetFramework
, string pathToSolution, string filePath, IDEProjectResult projectResult)
{
List <PortCoreConfiguration> configs = new List <PortCoreConfiguration>();
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = project,
UseDefaultRules = true,
TargetVersions = new List <string> {
targetFramework
},
PortCode = false,
PortProject = false
};
projectResult.ProjectPath = project;
configs.Add(projectConfiguration);
var solutionPort = new SolutionPort(pathToSolution, projectResult, configs);
return(solutionPort.RunIncremental(rootNodes, filePath));
}
public TestSolutionAnalysis AnalyzeSolution(string solutionName, string tempDir, string downloadLocation, string version, bool skipCopy = false)
{
TestSolutionAnalysis result = new TestSolutionAnalysis();
var sourceDir = Directory.GetParent(Directory.EnumerateFiles(downloadLocation, solutionName, SearchOption.AllDirectories).FirstOrDefault());
var solutionDir = Path.Combine(tempDir, version);
if (!skipCopy)
{
CopyDirectory(sourceDir, new DirectoryInfo(solutionDir));
}
else
{
solutionDir = tempDir;
}
string solutionPath = Directory.EnumerateFiles(solutionDir, solutionName, SearchOption.AllDirectories).FirstOrDefault();
if (solutionPath != null && solutionPath.Length > 0)
{
List <PortCoreConfiguration> solutionPortConfiguration = new List <PortCoreConfiguration>();
IEnumerable <string> projectFiles = Directory.EnumerateFiles(solutionDir, "*.csproj", SearchOption.AllDirectories);
if (projectFiles != null && projectFiles.Count() > 0)
{
foreach (string projectFile in projectFiles)
{
ProjectResult project = new ProjectResult();
Dictionary <string, string> packages = new Dictionary <string, string>();
packages.Add("Newtonsoft.Json", "*");
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = projectFile,
UseDefaultRules = true,
TargetVersions = new List <string> {
version
},
PackageReferences = packages
};
//project.CsProjectContent = File.ReadAllText(projectFile);
project.ProjectDirectory = Directory.GetParent(projectFile).FullName;
project.CsProjectPath = projectFile;
result.ProjectResults.Add(project);
solutionPortConfiguration.Add(projectConfiguration);
}
SolutionPort solutionPort = new SolutionPort(solutionPath, solutionPortConfiguration);
var analysisRunResult = solutionPort.AnalysisRun();
foreach (var projectAction in analysisRunResult.Values)
{
Assert.IsTrue(projectAction.ToSummaryString()?.Length > 0);
}
StringBuilder str = new StringBuilder();
foreach (var k in analysisRunResult.Keys)
{
StringBuilder projectResults = new StringBuilder();
projectResults.AppendLine(k);
projectResults.AppendLine(analysisRunResult[k].ToString());
result.ProjectResults.Where(p => p.CsProjectPath == k).FirstOrDefault().ProjectAnalysisResult = projectResults.ToString();
str.Append(projectResults);
}
result.SolutionAnalysisResult = str.ToString();
var runResult = solutionPort.Run();
result.SolutionRunResult = runResult;
foreach (var project in result.ProjectResults)
{
project.CsProjectContent = File.ReadAllText(project.CsProjectPath);
}
}
}
return(result);
}
private void InitProjectRewriter(AnalyzerResult analyzerResult, PortCoreConfiguration projectConfiguration)
{
InitRules(projectConfiguration, analyzerResult);
_projectRewriter = _projectRewriterFactory.GetInstance(analyzerResult, projectConfiguration);
}
private void InitProjectRewriter(AnalyzerResult analyzerResult, PortCoreConfiguration projectConfiguration)
{
InitRules(projectConfiguration, analyzerResult);
_projectRewriter = new ProjectRewriter(analyzerResult, projectConfiguration);
}
public TestSolutionAnalysis AnalyzeSolution(
string solutionPath,
string version,
Dictionary <string, List <string> > metaReferences = null,
bool skipCopy = false,
bool portCode = true,
bool portProject = true)
{
TestSolutionAnalysis result = new TestSolutionAnalysis();
var solutionDir = Directory.GetParent(solutionPath).FullName;
if (solutionPath != null && solutionPath.Length > 0)
{
List <PortCoreConfiguration> solutionPortConfiguration = new List <PortCoreConfiguration>();
IEnumerable <string> projectFiles = Directory.EnumerateFiles(solutionDir, "*.csproj", SearchOption.AllDirectories);
if (projectFiles != null && projectFiles.Count() > 0)
{
foreach (string projectFile in projectFiles)
{
Dictionary <string, Tuple <string, string> > packages = new Dictionary <string, Tuple <string, string> >
{
{ "Newtonsoft.Json", new Tuple <string, string>("9.0.0", "*") }
};
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = projectFile,
UseDefaultRules = true,
TargetVersions = new List <string> {
version
},
PackageReferences = packages,
PortCode = portCode,
PortProject = portProject
};
if (metaReferences != null)
{
projectConfiguration.MetaReferences = metaReferences.ContainsKey(projectFile) ? metaReferences[projectFile] : null;
}
solutionPortConfiguration.Add(projectConfiguration);
}
// SolutionPort should remove this extra config because it does not have a matching analyzer result.
// Otherwise will hit KeyNotFoundException
solutionPortConfiguration.Add(new PortCoreConfiguration
{
ProjectPath = "fakeproject.csproj",
UseDefaultRules = true,
});
SolutionPort solutionPort = new SolutionPort(solutionPath, solutionPortConfiguration);
CopyTestRules();
var analysisRunResult = solutionPort.AnalysisRun();
foreach (var projectResult in analysisRunResult.ProjectResults)
{
Assert.IsTrue(projectResult.ProjectActions.ToSummaryString()?.Length > 0);
}
var runResult = solutionPort.Run();
result = GenerateSolutionResult(solutionDir, analysisRunResult, runResult);
}
}
return(result);
}
static void Main(string[] args)
{
try
{
PortCoreRulesCli cli = new PortCoreRulesCli();
cli.HandleCommand(args);
Console.WriteLine(cli.FilePath);
/* 1. Logger object */
var loggerFactory = LoggerFactory.Create(builder => builder.SetMinimumLevel(LogLevel.Debug).AddConsole());
LogHelper.Logger = loggerFactory.CreateLogger("Translator");
if (string.IsNullOrEmpty(cli.RulesDir))
{
//TODO : Change the hard coded path to a constant
cli.RulesDir = Config.Constants.RulesDefaultPath;
}
if (cli.CreateNew)
{
cli.FilePath = Utils.CopySolutionToTemp(cli.FilePath);
}
var projectFiles = Utils.GetProjectPaths(cli.FilePath);
var packageReferences = new Dictionary <string, Tuple <string, string> >
{
{ "Microsoft.EntityFrameworkCore", new Tuple <string, string>("0.0.0", "*") }
};
List <PortCoreConfiguration> configs = new List <PortCoreConfiguration>();
foreach (var proj in projectFiles)
{
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
SolutionPath = cli.FilePath,
ProjectPath = proj,
RulesDir = cli.RulesDir,
IsMockRun = cli.IsMockRun,
UseDefaultRules = cli.DefaultRules,
PackageReferences = packageReferences,
PortCode = true,
PortProject = true,
TargetVersions = new List <string> {
cli.Version
}
};
configs.Add(projectConfiguration);
}
//Solution Rewriter:
SolutionPort solutionPort = new SolutionPort(cli.FilePath, configs);
var s = solutionPort.AnalysisRun();
foreach (var k in s.ProjectResults)
{
Console.WriteLine(k.ProjectFile);
Console.WriteLine(k.ProjectActions.ToString());
}
var portSolutionResult = solutionPort.Run();
}
catch (Exception ex)
{
LogHelper.LogError("Error while running solution rewriter: {0}", ex.Message);
}
}
public TestSolutionAnalysis AnalyzeSolution(
string solutionPath,
string version,
Dictionary <string, List <string> > metaReferences = null,
bool skipCopy = false,
bool portCode = true,
bool portProject = true)
{
TestSolutionAnalysis result = new TestSolutionAnalysis();
if (solutionPath != null && solutionPath.Length > 0)
{
List <PortCoreConfiguration> solutionPortConfiguration = new List <PortCoreConfiguration>();
IEnumerable <string> projectFiles = Utils.GetProjectPaths(solutionPath);
if (projectFiles != null && projectFiles.Count() > 0)
{
foreach (string projectFile in projectFiles)
{
Dictionary <string, Tuple <string, string> > packages = new Dictionary <string, Tuple <string, string> >
{
{ "Newtonsoft.Json", new Tuple <string, string>("9.0.0", "*") }
};
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
SolutionPath = solutionPath,
ProjectPath = projectFile,
UseDefaultRules = true,
TargetVersions = new List <string> {
version
},
PackageReferences = packages,
PortCode = portCode,
PortProject = portProject
};
if (metaReferences != null)
{
projectConfiguration.MetaReferences = metaReferences.ContainsKey(projectFile) ? metaReferences[projectFile] : null;
}
solutionPortConfiguration.Add(projectConfiguration);
result.ProjectResults.Add(new ProjectResult()
{
CsProjectPath = projectFile,
ProjectDirectory = Directory.GetParent(projectFile).FullName
});
}
// SolutionPort should remove this extra config because it does not have a matching analyzer result.
// Otherwise will hit KeyNotFoundException
solutionPortConfiguration.Add(new PortCoreConfiguration
{
SolutionPath = solutionPath,
ProjectPath = "fakeproject.csproj",
UseDefaultRules = true,
});
SolutionPort solutionPort = new SolutionPort(solutionPath, solutionPortConfiguration);
CopyTestRules();
var analysisRunResult = solutionPort.AnalysisRun();
StringBuilder str = new StringBuilder();
foreach (var projectResult in analysisRunResult.ProjectResults)
{
Assert.IsTrue(projectResult.ProjectActions.ToSummaryString()?.Length > 0);
StringBuilder projectResults = new StringBuilder();
projectResults.AppendLine(projectResult.ProjectFile);
projectResults.AppendLine(projectResult.ProjectActions.ToString());
result.ProjectResults.Where(p => p.CsProjectPath == projectResult.ProjectFile).FirstOrDefault().ProjectAnalysisResult = projectResults.ToString();
str.Append(projectResults);
}
result.SolutionAnalysisResult = str.ToString();
var runResult = solutionPort.Run();
foreach (var projectFile in result.ProjectResults)
{
projectFile.CsProjectContent = File.ReadAllText(projectFile.CsProjectPath);
}
result.SolutionRunResult = runResult;
}
}
return(result);
}
