public Model.Container GetContainer()
{
if (IsExcluded())
{
Console.WriteLine("Project {0} excluded from task", Options.ProjectName);
return(null);
}
else
{
var stopWatch = Stopwatch.StartNew();
Console.WriteLine("Processing Project: {0}", Options.ProjectName);
if (Options.ProjectDirectory != null)
{
Console.WriteLine("Using Project Directory: {0}", Options.ProjectDirectory);
}
Model.Container projectNode = new Model.Container();
projectNode.Name = Options.ProjectUniqueId;
projectNode.Version = Options.VersionName;
projectNode.SourcePath = Options.TargetPath;
projectNode.Type = "Project";
projectNode.OutputPaths = FindOutputPaths();
bool packagesConfigExists = !String.IsNullOrWhiteSpace(Options.PackagesConfigPath) && File.Exists(Options.PackagesConfigPath);
bool projectJsonExists = !String.IsNullOrWhiteSpace(Options.ProjectJsonPath) && File.Exists(Options.ProjectJsonPath);
bool projectJsonLockExists = !String.IsNullOrWhiteSpace(Options.ProjectJsonLockPath) && File.Exists(Options.ProjectJsonLockPath);
bool projectAssetsJsonExists = !String.IsNullOrWhiteSpace(Options.ProjectAssetsJsonPath) && File.Exists(Options.ProjectAssetsJsonPath);
if (packagesConfigExists)
{
Console.WriteLine("Using packages config: " + Options.PackagesConfigPath);
var packagesConfigResolver = new PackagesConfigResolver(Options.PackagesConfigPath, NugetService);
var packagesConfigResult = packagesConfigResolver.Process();
projectNode.Packages = packagesConfigResult.Packages;
projectNode.Dependencies = packagesConfigResult.Dependencies;
}
else if (projectJsonLockExists)
{
Console.WriteLine("Using json lock: " + Options.ProjectJsonLockPath);
var projectJsonLockResolver = new ProjectLockJsonResolver(Options.ProjectJsonLockPath);
var projectJsonLockResult = projectJsonLockResolver.Process();
projectNode.Packages = projectJsonLockResult.Packages;
projectNode.Dependencies = projectJsonLockResult.Dependencies;
}
else if (projectAssetsJsonExists)
{
Console.WriteLine("Using assets json file: " + Options.ProjectAssetsJsonPath);
var projectAssetsJsonResolver = new ProjectAssetsJsonResolver(Options.ProjectAssetsJsonPath);
var projectAssetsJsonResult = projectAssetsJsonResolver.Process();
projectNode.Packages = projectAssetsJsonResult.Packages;
projectNode.Dependencies = projectAssetsJsonResult.Dependencies;
}
else if (projectJsonExists)
{
Console.WriteLine("Using project json: " + Options.ProjectJsonPath);
var projectJsonResolver = new ProjectJsonResolver(Options.ProjectName, Options.ProjectJsonPath);
var projectJsonResult = projectJsonResolver.Process();
projectNode.Packages = projectJsonResult.Packages;
projectNode.Dependencies = projectJsonResult.Dependencies;
}
else
{
Console.WriteLine("Attempting reference resolver: " + Options.TargetPath);
var referenceResolver = new ProjectReferenceResolver(Options.TargetPath, NugetService);
var projectReferencesResult = referenceResolver.Process();
if (projectReferencesResult.Success)
{
Console.WriteLine("Reference resolver succeeded.");
projectNode.Packages = projectReferencesResult.Packages;
projectNode.Dependencies = projectReferencesResult.Dependencies;
}
else
{
Console.WriteLine("Using backup XML resolver.");
var xmlResolver = new ProjectXmlResolver(Options.TargetPath, NugetService);
var xmlResult = xmlResolver.Process();
projectNode.Version = xmlResult.ProjectVersion;
projectNode.Packages = xmlResult.Packages;
projectNode.Dependencies = xmlResult.Dependencies;
}
}
if (projectNode != null && projectNode.Dependencies != null && projectNode.Packages != null)
{
Console.WriteLine("Found {0} dependencies among {1} packages.", projectNode.Dependencies.Count, projectNode.Packages.Count);
}
Console.WriteLine("Finished processing project {0} which took {1} ms.", Options.ProjectName, stopWatch.ElapsedMilliseconds);
return(projectNode);
}
}
public Model.Container GetContainer()
{
Console.WriteLine("Processing Solution: " + Options.TargetPath);
var stopwatch = Stopwatch.StartNew();
Model.Container solution = new Model.Container();
solution.Name = Options.SolutionName;
solution.SourcePath = Options.TargetPath;
solution.Type = "Solution";
try
{
List <ProjectFile> projectFiles = FindProjectFilesFromSolutionFile(Options.TargetPath, ExcludedProjectTypeGUIDs);
Console.WriteLine("Parsed Solution File");
if (projectFiles.Count > 0)
{
string solutionDirectory = Path.GetDirectoryName(Options.TargetPath);
Console.WriteLine("Solution directory: {0}", solutionDirectory);
var duplicateNames = projectFiles
.GroupBy(project => project.Name)
.Where(group => group.Count() > 1)
.Select(group => group.Key);
var duplicatePaths = projectFiles
.GroupBy(project => project.Path)
.Where(group => group.Count() > 1)
.Select(group => group.Key);
foreach (ProjectFile project in projectFiles)
{
try
{
string projectRelativePath = project.Path;
List <string> projectPathSegments = new List <string>();
projectPathSegments.Add(solutionDirectory);
projectPathSegments.Add(projectRelativePath);
string projectPath = InspectorUtil.CreatePath(projectPathSegments);
string projectName = project.Name;
string projectId = projectName;
if (duplicateNames.Contains(projectId))
{
Console.WriteLine($"Duplicate project name '{projectName}' found. Using GUID instead.");
projectId = project.GUID;
}
Boolean projectFileExists = false;
try
{
projectFileExists = File.Exists(projectPath);
}
catch (Exception e)
{
Console.WriteLine("Skipping unknown project path: " + projectPath);
continue;
}
if (!projectFileExists)
{
Console.WriteLine("Skipping non-existent project path: " + projectPath);
continue;
}
ProjectInspector projectInspector = new ProjectInspector(new ProjectInspectionOptions(Options)
{
ProjectName = projectName,
ProjectUniqueId = projectId,
TargetPath = projectPath
}, NugetService);
InspectionResult projectResult = projectInspector.Inspect();
if (projectResult != null && projectResult.Containers != null)
{
solution.Children.AddRange(projectResult.Containers);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
if (Options.IgnoreFailure)
{
Console.WriteLine("Error inspecting project: {0}", project.Path);
Console.WriteLine("Error inspecting project. Cause: {0}", ex);
}
else
{
throw ex;
}
}
}
}
else
{
Console.WriteLine("No project data found for solution {0}", Options.TargetPath);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
if (Options.IgnoreFailure)
{
Console.WriteLine("Error executing Build BOM task. Cause: {0}", ex);
}
else
{
throw ex;
}
}
if (solution != null && solution.Children != null)
{
Console.WriteLine("Found " + solution.Children.Count + " children.");
}
Console.WriteLine("Finished processing solution: " + Options.TargetPath);
Console.WriteLine("Took " + stopwatch.ElapsedMilliseconds + " ms to process.");
return(solution);
}
