/// <summary>
/// Returns the <see cref="LockFile"/> object that
/// represents the contents of project.assets.json.
/// Used to identify project dependencies.
/// </summary>
///
/// <exception cref="SwitcherFileNotFoundException"/>
public static LockFile GetLockFile(ProjectReference reference)
{
return(LockFileUtilities.GetLockFile(reference.LockFile, NullLogger.Instance) ?? new LockFile());
}
private async Task <string> GetOutputInternalAsync(string outputPath, string projectPath, GenerationType generationType, string contextName, string migrationIdentifier, string nameSpace)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var launchPath = await DropNetCoreFilesAsync(outputPath);
var startupOutputPath = _project.DTE.GetStartupProjectOutputPath() ?? outputPath;
outputPath = FixExtension(outputPath);
startupOutputPath = FixExtension(startupOutputPath);
var startInfo = new ProcessStartInfo
{
FileName = Path.Combine(Path.GetDirectoryName(launchPath) ?? throw new InvalidOperationException(), "efpt.exe"),
Arguments = "\"" + outputPath + "\"",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
StandardOutputEncoding = Encoding.UTF8,
};
var outputs = " \"" + outputPath + "\" \"" + startupOutputPath + "\" ";
startInfo.Arguments = outputs;
if (generationType == GenerationType.Ddl)
{
startInfo.Arguments = "ddl" + outputs;
}
if (generationType == GenerationType.MigrationStatus)
{
startInfo.Arguments = "migrationstatus" + outputs;
}
if (generationType == GenerationType.MigrationApply)
{
startInfo.Arguments = "migrate" + outputs + contextName;
}
if (generationType == GenerationType.MigrationAdd)
{
startInfo.Arguments = "addmigration" + outputs + "\"" + projectPath + "\" " + contextName + " " + migrationIdentifier + " " + nameSpace;
}
if (generationType == GenerationType.MigrationScript)
{
startInfo.Arguments = "scriptmigration" + outputs + contextName;
}
var fileRoot = Path.Combine(Path.GetDirectoryName(outputPath), Path.GetFileNameWithoutExtension(outputPath));
var efptPath = Path.Combine(launchPath, "efpt.dll");
var depsFile = fileRoot + ".deps.json";
var runtimeConfig = fileRoot + ".runtimeconfig.json";
var projectAssetsFile = await _project.GetCspPropertyAsync("ProjectAssetsFile");
var runtimeFrameworkVersion = await _project.GetCspPropertyAsync("RuntimeFrameworkVersion");
var dotNetParams = $"exec --depsfile \"{depsFile}\" ";
if (projectAssetsFile != null && File.Exists(projectAssetsFile))
{
var lockFile = LockFileUtilities.GetLockFile(projectAssetsFile, NuGet.Common.NullLogger.Instance);
if (lockFile != null)
{
foreach (var packageFolder in lockFile.PackageFolders)
{
var path = packageFolder.Path.TrimEnd('\\');
dotNetParams += $"--additionalprobingpath \"{path}\" ";
}
}
}
if (File.Exists(runtimeConfig))
{
dotNetParams += $"--runtimeconfig \"{runtimeConfig}\" ";
}
else if (runtimeFrameworkVersion != null)
{
dotNetParams += $"--fx-version {runtimeFrameworkVersion} ";
}
dotNetParams += $"\"{efptPath}\" ";
startInfo.WorkingDirectory = Path.GetDirectoryName(outputPath);
startInfo.FileName = "dotnet";
startInfo.Arguments = dotNetParams + " " + startInfo.Arguments;
Debug.WriteLine(startInfo.Arguments);
var standardOutput = new StringBuilder();
using (var process = System.Diagnostics.Process.Start(startInfo))
{
while (process != null && !process.HasExited)
{
standardOutput.Append(await process.StandardOutput.ReadToEndAsync());
}
if (process != null)
{
standardOutput.Append(await process.StandardOutput.ReadToEndAsync());
}
}
return(standardOutput.ToString());
}
private async Task <List <ProjectDependency> > ResolvePackageReferencesAsync(ILogger logger, CancellationToken cancellationToken)
{
ThrowOnDisposed();
cancellationToken.ThrowIfCancellationRequested();
var packageDependencies = new List <ProjectDependency>();
using (var safeLogger = await SafeLogger.WriteStartOperationAsync(logger, "Resolving package references ...").ConfigureAwait(false))
{
await AsyncHelper.RunAsync(async() =>
{
try
{
var assetsFile = new FileInfo(Path.Combine(this.DirectoryPath, "obj", "project.assets.json")).FullName;
if (File.Exists(assetsFile))
{
LockFile lockFile = LockFileUtilities.GetLockFile(assetsFile, logger as NuGet.Common.ILogger);
if (lockFile != null)
{
if (lockFile.Targets.Count == 1)
{
foreach (var lib in lockFile.Targets[0].Libraries)
{
bool isPackage = StringComparer.OrdinalIgnoreCase.Compare(lib.Type, "package") == 0;
if (isPackage)
{
foreach (var compiletimeAssembly in lib.CompileTimeAssemblies)
{
if (Path.GetExtension(compiletimeAssembly.Path) == ".dll")
{
var dependency = ProjectDependency.FromPackage(Path.GetFileNameWithoutExtension(compiletimeAssembly.Path), lib.Name, lib.Version.ToNormalizedString());
var itemIdx = packageDependencies.IndexOf(dependency);
if (itemIdx == -1)
{
packageDependencies.Add(dependency);
}
else if (dependency.IsFramework)
{
// packages can be described individually and/or as part of a platform metapackage in the lock file; for instance: Microsoft.CSharp is a package that is part of Microsoft.NetCore.
packageDependencies[itemIdx] = dependency;
}
}
}
}
}
packageDependencies.Sort();
}
else
{
await safeLogger.WriteWarningAsync(Shared.Resources.WarningMultiFxOrNoSupportedDnxVersion, logToUI: true).ConfigureAwait(false);
}
}
else
{
await safeLogger.WriteWarningAsync(Shared.Resources.WarningCannotResolveProjectReferences, logToUI: true).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
if (Utils.IsFatalOrUnexpected(ex))
{
throw;
}
await safeLogger.WriteWarningAsync(ex.Message, logToUI: false).ConfigureAwait(false);
}
}, cancellationToken).ConfigureAwait(false);
await safeLogger.WriteMessageAsync($"Package reference count: {packageDependencies.Count}", logToUI : false).ConfigureAwait(false);
}
return(packageDependencies);
}
private async Task <IEnumerable <ToolRestoreResult> > ExecuteToolRestoresAsync(
NuGetv3LocalRepository userPackageFolder,
IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders,
CancellationToken token)
{
var toolPathResolver = new ToolPathResolver(_request.PackagesDirectory);
var results = new List <ToolRestoreResult>();
var localRepositories = new List <NuGetv3LocalRepository>();
localRepositories.Add(userPackageFolder);
localRepositories.AddRange(fallbackPackageFolders);
foreach (var tool in _request.Project.Tools)
{
_logger.LogMinimal(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RestoringToolPackages,
tool.LibraryRange.Name,
_request.Project.FilePath));
// Build the fallback framework (which uses the "imports").
var framework = LockFile.ToolFramework;
if (tool.Imports.Any())
{
framework = new FallbackFramework(framework, tool.Imports);
}
// Build a package spec in memory to execute the tool restore as if it were
// its own project. For now, we always restore for a null runtime and a single
// constant framework.
var toolPackageSpec = new PackageSpec(new JObject())
{
Name = Guid.NewGuid().ToString(), // make sure this package never collides with a dependency
Dependencies = new List <LibraryDependency>(),
Tools = new List <ToolDependency>(),
TargetFrameworks =
{
new TargetFrameworkInformation
{
FrameworkName = framework,
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = tool.LibraryRange
}
}
}
}
};
// Try to find the existing lock file. Since the existing lock file is pathed under
// a folder that includes the resolved tool's version, this is a bit of a chicken
// and egg problem. That is, we need to run the restore operation in order to resolve
// a tool version, but we need the tool version to find the existing project.lock.json
// file which is required before executing the restore! Fortunately, this is solved by
// looking at the tool's consuming project's lock file to see if the tool has been
// restored before.
LockFile existingToolLockFile = null;
if (_request.ExistingLockFile != null)
{
var existingTarget = _request
.ExistingLockFile
.Tools
.Where(t => t.RuntimeIdentifier == null)
.Where(t => t.TargetFramework.Equals(LockFile.ToolFramework))
.FirstOrDefault();
var existingLibrary = existingTarget?.Libraries
.Where(l => StringComparer.OrdinalIgnoreCase.Equals(l.Name, tool.LibraryRange.Name))
.Where(l => tool.LibraryRange.VersionRange.Satisfies(l.Version))
.FirstOrDefault();
if (existingLibrary != null)
{
var existingLockFilePath = toolPathResolver.GetLockFilePath(
existingLibrary.Name,
existingLibrary.Version,
existingTarget.TargetFramework);
existingToolLockFile = LockFileUtilities.GetLockFile(existingLockFilePath, _logger);
}
}
// Execute the restore.
var toolSuccess = true; // success for this individual tool restore
var runtimeIds = new HashSet <string>();
var projectFrameworkRuntimePairs = CreateFrameworkRuntimePairs(toolPackageSpec, runtimeIds);
var allInstalledPackages = new HashSet <LibraryIdentity>();
var contextForTool = CreateRemoteWalkContext(_request);
var walker = new RemoteDependencyWalker(contextForTool);
var projectRestoreRequest = new ProjectRestoreRequest(
_request,
toolPackageSpec,
existingToolLockFile,
new Dictionary <NuGetFramework, RuntimeGraph>(),
_runtimeGraphCacheByPackage);
var projectRestoreCommand = new ProjectRestoreCommand(_logger, projectRestoreRequest);
var result = await projectRestoreCommand.TryRestore(
tool.LibraryRange,
projectFrameworkRuntimePairs,
allInstalledPackages,
userPackageFolder,
fallbackPackageFolders,
walker,
contextForTool,
forceRuntimeGraphCreation : false,
token : token);
var graphs = result.Item2;
if (!result.Item1)
{
toolSuccess = false;
_success = false;
}
// Create the lock file (in memory).
var toolLockFile = BuildLockFile(
existingToolLockFile,
toolPackageSpec,
graphs,
localRepositories,
contextForTool,
Enumerable.Empty <ToolRestoreResult>());
// Build the path based off of the resolved tool. For now, we assume there is only
// ever one target.
var target = toolLockFile.Targets.Single();
var fileTargetLibrary = target
.Libraries
.FirstOrDefault(l => StringComparer.OrdinalIgnoreCase.Equals(tool.LibraryRange.Name, l.Name));
string toolLockFilePath = null;
if (fileTargetLibrary != null)
{
toolLockFilePath = toolPathResolver.GetLockFilePath(
fileTargetLibrary.Name,
fileTargetLibrary.Version,
target.TargetFramework);
}
// Validate the results.
if (!ValidateRestoreGraphs(graphs, _logger))
{
toolSuccess = false;
_success = false;
}
var checkResults = VerifyCompatibility(
toolPackageSpec,
new Dictionary <RestoreTargetGraph, Dictionary <string, LibraryIncludeFlags> >(),
localRepositories,
toolLockFile,
graphs,
_logger);
if (checkResults.Any(r => !r.Success))
{
toolSuccess = false;
_success = false;
}
results.Add(new ToolRestoreResult(
tool.LibraryRange.Name,
toolSuccess,
target,
fileTargetLibrary,
toolLockFilePath,
toolLockFile,
existingToolLockFile));
}
return(results);
}
private static bool GenerateLockFile(string dir, string assetsFilePath)
{
if (!File.Exists(assetsFilePath))
{
// TODO auto-restore?
Console.Error.WriteLine("Could not find project.assets.json. Make sure to run 'dotnet restore' first before locking the file");
return(false);
}
var lockFilePath = Path.Combine(dir, LockFileName);
var assetsFile = LockFileUtilities.GetLockFile(assetsFilePath, NullLogger.Instance);
var proj = new XElement("Project");
var doc = new XDocument(proj);
// details
var props = new XElement("PropertyGroup");
props.Add(new XElement("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)"));
props.Add(new XElement("NuGetLockFileVersion", GetVersion()));
props.Add(new XElement("NuGetLockFileImported", "true"));
// force NuGet to error out if there are issues
props.Add(new XElement("WarningsAsErrors", "$(WarningsAsErrors)" + FatalErrors.Aggregate(string.Empty, (sum, piece) => $"{sum};{piece}")));
proj.Add(props);
// clear all package reference items
proj.Add(new XElement("ItemGroup",
new XElement("PackageReference", new XAttribute("Remove", "@(PackageReference)"))));
// also naive. Multiple targets make exist if there are runtime identifiers
foreach (var target in assetsFile.Targets.OrderBy(t => t.TargetFramework.GetShortFolderName()))
{
var spec = assetsFile.PackageSpec.GetTargetFramework(target.TargetFramework);
var itemGroup = new XElement("ItemGroup", new XAttribute("Condition", $"'$(TargetFramework)' == '{target.TargetFramework.GetShortFolderName()}'"));
proj.Add(itemGroup);
foreach (var library in target.Libraries.OrderBy(l => l.Name).Where(l => !l.Type.Equals("project", StringComparison.Ordinal)))
{
// TODO re-add PrivateAssets, ExcludeAssets, etc. where appropriate
var reference = new XElement("PackageReference", new XAttribute("Include", library.Name), new XAttribute("Version", library.Version.ToNormalizedString()));
var refSpec = spec.Dependencies.FirstOrDefault(l => l.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase));
if (refSpec != null)
{
if (refSpec.AutoReferenced)
{
reference.Add(new XAttribute("IsImplicitlyDefined", "true"));
}
if (refSpec.NoWarn.Any())
{
reference.Add(new XAttribute("NoWarn", refSpec.NoWarn.Aggregate(string.Empty, (a, b) => $"{a};{b}")));
}
if (refSpec.SuppressParent == LibraryIncludeFlags.All)
{
reference.Add(new XAttribute("PrivateAssets", "All"));
}
if (refSpec.IncludeType != LibraryIncludeFlags.All)
{
reference.Add(
new XAttribute("IncludeAssets", LibraryIncludeFlagUtils.GetFlagString(refSpec.IncludeType).Replace(", ", ";")));
}
}
else
{
bool IsEmptyFile(LockFileItem item)
{
return(Path.GetFileName(item.Path).Equals("_._", StringComparison.Ordinal));
}
// Attempt to make this as similar to a transitive dependency as possible
// This info is just for us. No one uses it (yet).
reference.Add(new XAttribute("Transitive", "true"));
// Add PrivateAssets="All" to ensure only top-level dependencies end up in the generated nuspec
reference.Add(new XAttribute("PrivateAssets", "All"));
// in some cases, the parent package may exclude assets from their nuspec.
// We don't want to change the compile graph by lifting this to be a top-level PackageRef
var excludeFlags = LibraryIncludeFlags.None;
if (library.CompileTimeAssemblies.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Compile;
}
if (library.RuntimeAssemblies.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Runtime;
}
if (library.NativeLibraries.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Native;
}
if (library.Build.Count(IsEmptyFile) == 1 ||
library.BuildMultiTargeting.Count(IsEmptyFile) == 1)
{
excludeFlags |= LibraryIncludeFlags.Build;
}
reference.Add(new XAttribute("ExcludeAssets", LibraryIncludeFlagUtils.GetFlagString(excludeFlags)));
}
itemGroup.Add(reference);
}
}
#if NETCOREAPP1_0
using (var stream = File.Open(lockFilePath, FileMode.Create))
{
doc.Save(stream);
}
#elif NETCOREAPP2_0
doc.Save(lockFilePath);
#else
#error Update target frameworks
#endif
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write($"Generated lock file: ");
Console.ResetColor();
Console.WriteLine(lockFilePath);
Console.WriteLine("This file should be commited to source control.");
return(true);
}
public List <Project> AnalyzeProject(string projectPath, bool runRestore, bool includeTransitiveDependencies, int transitiveDepth)
{
var dependencyGraph = _dependencyGraphService.GenerateDependencyGraph(projectPath);
if (dependencyGraph == null)
{
return(null);
}
var projects = new List <Project>();
foreach (var packageSpec in dependencyGraph.Projects.Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference))
{
// Restore the packages
if (runRestore)
{
_dotNetRestoreService.Restore(packageSpec.FilePath);
}
// Load the lock file
string lockFilePath = _fileSystem.Path.Combine(packageSpec.RestoreMetadata.OutputPath, "project.assets.json");
var lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance);
// Create a project
var project = new Project(packageSpec.Name, packageSpec.FilePath, packageSpec.RestoreMetadata.Sources.Select(s => s.SourceUri).ToList(), packageSpec.Version);
projects.Add(project);
// Get the target frameworks with their dependencies
foreach (var targetFrameworkInformation in packageSpec.TargetFrameworks)
{
var targetFramework = new TargetFramework(targetFrameworkInformation.FrameworkName);
project.TargetFrameworks.Add(targetFramework);
var target = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFrameworkInformation.FrameworkName));
if (target != null)
{
foreach (var projectDependency in targetFrameworkInformation.Dependencies)
{
var projectLibrary = target.Libraries.FirstOrDefault(library => string.Equals(library.Name, projectDependency.Name, StringComparison.OrdinalIgnoreCase));
bool isDevelopmentDependency = false;
if (projectLibrary != null)
{
// Determine whether this is a development dependency
var packageIdentity = new PackageIdentity(projectLibrary.Name, projectLibrary.Version);
var packageInfo = LocalFolderUtility.GetPackageV3(packageSpec.RestoreMetadata.PackagesPath, packageIdentity, NullLogger.Instance);
if (packageInfo != null)
{
isDevelopmentDependency = packageInfo.GetReader().GetDevelopmentDependency();
}
}
var dependency = new Dependency(projectDependency.Name, projectDependency.LibraryRange.VersionRange, projectLibrary?.Version,
projectDependency.AutoReferenced, false, isDevelopmentDependency);
targetFramework.Dependencies.Add(dependency);
// Process transitive dependencies for the library
if (includeTransitiveDependencies)
{
AddDependencies(targetFramework, projectLibrary, target, 1, transitiveDepth);
}
}
}
}
}
return(projects);
}
public List <Project> AnalyzeProject(string projectPath, bool includeTransitiveDependencies, int transitiveDepth)
{
var dependencyGraph = _dependencyGraphService.GenerateDependencyGraph(projectPath);
if (dependencyGraph == null)
{
return(null);
}
var projects = new List <Project>();
foreach (var packageSpec in dependencyGraph.Projects.Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference))
{
// Restore the packages
_dotNetRestoreService.Restore(packageSpec.FilePath);
// Load the lock file
string lockFilePath = _fileSystem.Path.Combine(packageSpec.RestoreMetadata.OutputPath, "project.assets.json");
var lockFile = LockFileUtilities.GetLockFile(lockFilePath, NuGet.Common.NullLogger.Instance);
// Create a project
var project = new Project
{
Name = packageSpec.Name,
Sources = packageSpec.RestoreMetadata.Sources.Select(s => s.SourceUri).ToList(),
FilePath = packageSpec.FilePath
};
projects.Add(project);
// Get the target frameworks with their dependencies
foreach (var targetFrameworkInformation in packageSpec.TargetFrameworks)
{
var targetFramework = new Project.TargetFramework
{
Name = targetFrameworkInformation.FrameworkName,
};
project.TargetFrameworks.Add(targetFramework);
var target = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFrameworkInformation.FrameworkName));
if (target != null)
{
foreach (var projectDependency in targetFrameworkInformation.Dependencies)
{
var projectLibrary = target.Libraries.FirstOrDefault(library => string.Equals(library.Name, projectDependency.Name, StringComparison.OrdinalIgnoreCase));
var dependency = new Project.Dependency
{
Name = projectDependency.Name,
VersionRange = projectDependency.LibraryRange.VersionRange,
ResolvedVersion = projectLibrary?.Version,
IsAutoReferenced = projectDependency.AutoReferenced,
IsTransitive = false
};
targetFramework.Dependencies.Add(dependency);
// Process transitive dependencies for the library
if (includeTransitiveDependencies)
{
AddDependencies(targetFramework, projectLibrary, target, 1, transitiveDepth);
}
}
}
}
}
return(projects);
}
private async Task <string> GetOutputInternalAsync(string outputPath, string projectPath, GenerationType generationType, string contextName, string migrationIdentifier, string nameSpace)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var launchPath = await DropNetCoreFilesAsync();
var startupOutputPath = await EnvDTEExtensions.GetStartupProjectOutputPathAsync() ?? outputPath;
outputPath = FixExtension(outputPath);
startupOutputPath = FixExtension(startupOutputPath);
var startInfo = new ProcessStartInfo
{
FileName = Path.Combine(Path.GetDirectoryName(launchPath) ?? throw new InvalidOperationException(), "efpt.exe"),
Arguments = "\"" + outputPath + "\"",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
StandardOutputEncoding = Encoding.UTF8,
};
var outputs = " \"" + outputPath + "\" \"" + startupOutputPath + "\" ";
startInfo.Arguments = outputs;
switch (generationType)
{
case GenerationType.Dgml:
break;
case GenerationType.Ddl:
startInfo.Arguments = "ddl" + outputs;
break;
case GenerationType.DebugView:
break;
case GenerationType.MigrationStatus:
startInfo.Arguments = "migrationstatus" + outputs;
break;
case GenerationType.MigrationApply:
startInfo.Arguments = "migrate" + outputs + contextName;
break;
case GenerationType.MigrationAdd:
startInfo.Arguments = "addmigration" + outputs + "\"" + projectPath + "\" " + contextName + " " + migrationIdentifier + " " + nameSpace;
break;
case GenerationType.MigrationScript:
startInfo.Arguments = "scriptmigration" + outputs + contextName;
break;
case GenerationType.DbContextList:
startInfo.Arguments = "contextlist" + outputs;
break;
case GenerationType.DbContextCompare:
startInfo.Arguments = "schemacompare" + outputs + "\"" + migrationIdentifier + "\" " + contextName;
break;
default:
break;
}
var fileRoot = Path.Combine(Path.GetDirectoryName(outputPath), Path.GetFileNameWithoutExtension(outputPath));
var efptPath = Path.Combine(launchPath, "efpt.dll");
var depsFile = fileRoot + ".deps.json";
var runtimeConfig = fileRoot + ".runtimeconfig.json";
var projectAssetsFile = await _project.GetAttributeAsync("ProjectAssetsFile");
var runtimeFrameworkVersion = await _project.GetAttributeAsync("RuntimeFrameworkVersion");
var dotNetParams = $"exec --depsfile \"{depsFile}\" ";
if (projectAssetsFile != null && File.Exists(projectAssetsFile))
{
var lockFile = LockFileUtilities.GetLockFile(projectAssetsFile, NuGet.Common.NullLogger.Instance);
if (lockFile != null)
{
foreach (var packageFolder in lockFile.PackageFolders)
{
var path = packageFolder.Path.TrimEnd('\\');
dotNetParams += $"--additionalprobingpath \"{path}\" ";
}
}
}
if (File.Exists(runtimeConfig))
{
dotNetParams += $"--runtimeconfig \"{runtimeConfig}\" ";
}
else if (!string.IsNullOrEmpty(runtimeFrameworkVersion))
{
dotNetParams += $"--fx-version {runtimeFrameworkVersion} ";
}
dotNetParams += $"\"{efptPath}\" ";
startInfo.WorkingDirectory = Path.GetDirectoryName(outputPath);
startInfo.FileName = "dotnet";
startInfo.Arguments = dotNetParams + " " + startInfo.Arguments;
try
{
File.WriteAllText(Path.Combine(Path.GetTempPath(), "efptparams.txt"), startInfo.Arguments);
}
catch
{
// Ignore
}
var standardOutput = new StringBuilder();
var error = string.Empty;
using (var process = System.Diagnostics.Process.Start(startInfo))
{
while (process != null && !process.HasExited)
{
standardOutput.Append(await process.StandardOutput.ReadToEndAsync());
}
if (process != null)
{
standardOutput.Append(await process.StandardOutput.ReadToEndAsync());
}
if (process != null)
{
error = await process.StandardError.ReadToEndAsync();
}
}
var result = standardOutput.ToString();
if (string.IsNullOrEmpty(result) && !string.IsNullOrEmpty(error))
{
result = "Error:" + Environment.NewLine + error;
}
return(result);
}
void Execute(MetadataResolver resolver)
{
foreach (var dir in ReferenceAssembliesDirectory.Split(new char [] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
resolver.AddSearchDirectory(dir);
}
var assemblies = new Dictionary <string, ITaskItem> (Assemblies.Length);
var topAssemblyReferences = new List <string> (Assemblies.Length);
var logger = new NuGetLogger((s) => {
LogDebugMessage("{0}", s);
});
LockFile lockFile = null;
if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
{
lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
}
try {
foreach (var assembly in Assemblies)
{
// Add each user assembly and all referenced assemblies (recursive)
string resolved_assembly = resolver.Resolve(assembly.ItemSpec);
bool refAssembly = !string.IsNullOrEmpty(assembly.GetMetadata("NuGetPackageId")) && resolved_assembly.Contains($"{Path.DirectorySeparatorChar}ref{Path.DirectorySeparatorChar}");
if (refAssembly || MonoAndroidHelper.IsReferenceAssembly(resolved_assembly))
{
// Resolve "runtime" library
if (lockFile != null)
{
resolved_assembly = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, assembly.ItemSpec);
}
if (lockFile == null || resolved_assembly == null)
{
var file = resolved_assembly ?? assembly.ItemSpec;
LogCodedWarning("XA0107", file, 0, "Ignoring Reference Assembly `{0}`.", file);
continue;
}
}
LogDebugMessage($"Adding {resolved_assembly} to topAssemblyReferences");
topAssemblyReferences.Add(resolved_assembly);
resolver.AddSearchDirectory(Path.GetDirectoryName(resolved_assembly));
var taskItem = new TaskItem(assembly)
{
ItemSpec = Path.GetFullPath(resolved_assembly),
};
if (string.IsNullOrEmpty(taskItem.GetMetadata("ReferenceAssembly")))
{
taskItem.SetMetadata("ReferenceAssembly", taskItem.ItemSpec);
}
string assemblyName = Path.GetFileNameWithoutExtension(resolved_assembly);
assemblies [assemblyName] = taskItem;
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return;
}
try {
foreach (var assembly in topAssemblyReferences)
{
AddAssemblyReferences(resolver, assemblies, assembly, null);
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return;
}
// Add I18N assemblies if needed
AddI18nAssemblies(resolver, assemblies);
var mainapiLevel = MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion);
foreach (var item in api_levels.Where(x => mainapiLevel < x.Value))
{
var itemOSVersion = MonoAndroidHelper.SupportedVersions.GetFrameworkVersionFromApiLevel(item.Value);
LogCodedWarning("XA0105", ProjectFile, 0,
"The $(TargetFrameworkVersion) for {0} ({1}) is greater than the $(TargetFrameworkVersion) for your project ({2}). " +
"You need to increase the $(TargetFrameworkVersion) for your project.", Path.GetFileName(item.Key), itemOSVersion, TargetFrameworkVersion);
}
var resolvedAssemblies = new List <ITaskItem> (assemblies.Count);
var resolvedSymbols = new List <ITaskItem> (assemblies.Count);
var resolvedFrameworkAssemblies = new List <ITaskItem> (assemblies.Count);
var resolvedUserAssemblies = new List <ITaskItem> (assemblies.Count);
foreach (var assembly in assemblies.Values)
{
var mdb = assembly + ".mdb";
var pdb = Path.ChangeExtension(assembly.ItemSpec, "pdb");
if (File.Exists(mdb))
{
resolvedSymbols.Add(new TaskItem(mdb));
}
if (File.Exists(pdb) && Files.IsPortablePdb(pdb))
{
resolvedSymbols.Add(new TaskItem(pdb));
}
resolvedAssemblies.Add(assembly);
if (MonoAndroidHelper.IsFrameworkAssembly(assembly.ItemSpec, checkSdkPath: true))
{
resolvedFrameworkAssemblies.Add(assembly);
}
else
{
resolvedUserAssemblies.Add(assembly);
}
}
ResolvedAssemblies = resolvedAssemblies.ToArray();
ResolvedSymbols = resolvedSymbols.ToArray();
ResolvedFrameworkAssemblies = resolvedFrameworkAssemblies.ToArray();
ResolvedUserAssemblies = resolvedUserAssemblies.ToArray();
ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
}
public override bool TryGetPackages(string packageConfigPath, PackageRestoreData packageRestoreData, out IEnumerable <PackageIdentityWithPath> packages)
{
packages = null;
// This parser cannot do anything for packages.config or project.json
//
if (NuGetPackagesConfigParser.IsPackagesConfigFile(packageConfigPath) || ProjectJsonPathUtilities.IsProjectConfig(packageConfigPath))
{
return(false);
}
// This parser requires that the restore info file was created
//
if (packageRestoreData == null)
{
Log.LogMessage("Missing expected assets file directory. This is typically because the flag generated at $(CBTModuleNuGetAssetsFlagFile) does not exist or is empty. Ensure the GenerateModuleAssetFlagFile target is running. It may also be because the CBTModules.proj does not import CBT build.props in some fashion.");
return(false);
}
if (!String.Equals("PackageReference", packageRestoreData.RestoreProjectStyle, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
string lockFilePath = Path.Combine(packageRestoreData.RestoreOutputAbsolutePath, LockFileFormat.AssetsFileName);
if (!File.Exists(lockFilePath))
{
throw new FileNotFoundException($"Missing expected NuGet assets file '{lockFilePath}'. If you are redefining BaseIntermediateOutputPath ensure it is unique per project. ");
}
HashSet <string> processedPackages = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
LockFile lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance);
string globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NuGetSettings);
if (String.IsNullOrWhiteSpace(globalPackagesFolder))
{
throw new NuGetConfigurationException(@"Unable to determine the NuGet repository path. This usually defaults to ""%UserProfile%\.nuget\packages"", ""%NUGET_PACKAGES%"", or the ""globalPackagesFolder"" in your NuGet.config.");
}
globalPackagesFolder = Path.GetFullPath(globalPackagesFolder);
if (!Directory.Exists(globalPackagesFolder))
{
throw new DirectoryNotFoundException($"The NuGet repository '{globalPackagesFolder}' does not exist. Ensure that NuGet restored packages to the location specified in your NuGet.config.");
}
Log.LogMessage(MessageImportance.Low, $"Using repository path: '{globalPackagesFolder}'");
VersionFolderPathResolver versionFolderPathResolver = new VersionFolderPathResolver(globalPackagesFolder);
packages = new List <PackageIdentityWithPath>();
foreach (RestorePackage package in packageRestoreData.PackageImportOrder)
{
// In <PackageReference only one version of a nuGet package will be installed. That version may not be the one specified in the <PackageReference item. So we can not match the version specified in the CBTModules.proj with the version actually installed. If we want to do any such matching it would simply need to result in a build error.
IEnumerable <PackageDependency> dependencies = lockFile.Targets.First().Libraries.Where(lib => lib.Name.Equals(package.Id, StringComparison.OrdinalIgnoreCase)).Select(lib => lib.Dependencies).SelectMany(p => p.Select(i => i));
foreach (PackageDependency dependency in dependencies)
{
// In the <PackageReference scenario nuGet will only install one packageId. If you have two packages that reference different package versions of a third package then it will choose the common highest version and if there is no common version it will error. If you have two packages listed with two different versions it will choose the first entry and silently not install the other.
// If the package is already processed then skip. If the package is explicitly added then skip to use that order.
if (!processedPackages.Contains(dependency.Id, StringComparer.OrdinalIgnoreCase) && !packageRestoreData.PackageImportOrder.Any(pio => pio.Id.Equals(dependency.Id, StringComparison.OrdinalIgnoreCase)))
{
LockFileLibrary installedPackage = lockFile.Libraries.First(lockPkg => lockPkg.Name.Equals(dependency.Id, StringComparison.OrdinalIgnoreCase));
processedPackages.Add(dependency.Id);
AddPackage((List <PackageIdentityWithPath>)packages, installedPackage, versionFolderPathResolver);
}
}
if (!processedPackages.Contains(package.Id))
{
LockFileLibrary installedPackage = lockFile.Libraries.First(lockPkg => lockPkg.Name.Equals(package.Id, StringComparison.OrdinalIgnoreCase));
processedPackages.Add(package.Id);
AddPackage((List <PackageIdentityWithPath>)packages, installedPackage, versionFolderPathResolver);
}
}
return(true);
}
/// <summary>
/// Returns the <see cref="LockFile"/> object that
/// represents the contents of project.assets.json.
/// Used to identify project dependencies.
/// </summary>
///
/// <exception cref="SwitcherFileNotFoundException"/>
protected virtual LockFile GetLockFile(IProjectReference reference)
{
return(LockFileUtilities.GetLockFile(reference.GetLockFile(), NullLogger.Instance) ?? new LockFile());
}
public override bool TryGetPackages(string packageConfigPath, PackageRestoreData packageRestoreData, out IEnumerable <PackageIdentityWithPath> packages)
{
packages = null;
string projectJsonPath;
if (ProjectJsonPathUtilities.IsProjectConfig(packageConfigPath))
{
projectJsonPath = packageConfigPath;
}
else
{
if (!String.Equals("ProjectJson", packageRestoreData?.RestoreProjectStyle, StringComparison.OrdinalIgnoreCase) || String.IsNullOrWhiteSpace(packageRestoreData?.ProjectJsonPath))
{
return(false);
}
projectJsonPath = packageRestoreData.ProjectJsonPath;
}
string lockFilePath = ProjectJsonPathUtilities.GetLockFilePath(projectJsonPath);
if (!File.Exists(lockFilePath))
{
throw new FileNotFoundException($"The lock file '{lockFilePath}' does not exist. Ensure that the restore succeeded and that the lock file was generated.");
}
LockFile lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance);
string globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NuGetSettings);
if (String.IsNullOrWhiteSpace(globalPackagesFolder))
{
throw new NuGetConfigurationException(@"Unable to determine the NuGet repository path. This usually defaults to ""%UserProfile%\.nuget\packages"", ""%NUGET_PACKAGES%"", or the ""globalPackagesFolder"" in your NuGet.config.");
}
globalPackagesFolder = Path.GetFullPath(globalPackagesFolder);
if (!Directory.Exists(globalPackagesFolder))
{
throw new DirectoryNotFoundException($"The NuGet repository '{globalPackagesFolder}' does not exist. Ensure that NuGet is restore packages to the location specified in your NuGet.config.");
}
Log.LogMessage(MessageImportance.Low, $"Using repository path: '{globalPackagesFolder}'");
VersionFolderPathResolver versionFolderPathResolver = new VersionFolderPathResolver(globalPackagesFolder);
packages = lockFile.Libraries.Select(i =>
{
string installPath = versionFolderPathResolver.GetInstallPath(i.Name, i.Version);
if (!String.IsNullOrWhiteSpace(installPath))
{
installPath = Path.GetFullPath(installPath);
}
else
{
Log.LogWarning($"The package '{i.Name}' was not found in the repository.");
}
return(new PackageIdentityWithPath(i.Name, i.Version, installPath));
}).Where(i => !String.IsNullOrWhiteSpace(i.FullPath));
return(true);
}
public LockFile GetLockFile()
{
return(LockFileUtilities.GetLockFile(_project.GetAssetsFilePathAsync().Result, _projectContext.LoggerAdapter));
}
public async Task DotnetToolTests_ToolRestoreWithRuntimeIdentiferGraphPath_SucceedsAsync()
{
using (var testDirectory = _msbuildFixture.CreateTestDirectory())
{
var tfm = "netcoreapp2.0";
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var source = Path.Combine(testDirectory, "packageSource");
var rid = "win-x64";
var packageRid = "win";
var packageName = string.Join("ToolPackage-", tfm, rid);
var packageVersion = NuGetVersion.Parse("1.0.0");
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion)
};
var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
package.Files.Clear();
package.AddFile($"tools/{tfm}/{packageRid}/a.dll");
package.AddFile($"tools/{tfm}/{packageRid}/Settings.json");
package.PackageType = PackageType.DotnetTool;
package.UseDefaultRuntimeAssemblies = false;
package.PackageTypes.Add(PackageType.DotnetTool);
await SimpleTestPackageUtility.CreatePackagesAsync(source, package);
_msbuildFixture.CreateDotnetToolProject(solutionRoot: testDirectory.Path,
projectName: projectName, targetFramework: tfm, rid: rid,
source: source, packages: packages);
// set up rid graph
var ridGraphPath = Path.Combine(testDirectory.Path, "runtime.json");
File.WriteAllBytes(ridGraphPath, GetTestUtilityResource("runtime.json"));
using (var stream = File.Open(Path.Combine(workingDirectory, projectName + ".csproj"), FileMode.Open, FileAccess.ReadWrite))
{
var xml = XDocument.Load(stream);
ProjectFileUtils.AddProperty(
xml,
"RuntimeIdentifierGraphPath",
ridGraphPath);
ProjectFileUtils.WriteXmlToFile(xml, stream);
}
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
Assert.True(result.Item1 == 0, result.AllOutput);
// Verify the assets file
var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
var toolsAssemblies = ridTargets.First().Libraries.First().ToolsAssemblies;
Assert.Equal(2, toolsAssemblies.Count);
Assert.True(toolsAssemblies.Contains($"tools/{tfm}/{packageRid}/a.dll"));
Assert.True(toolsAssemblies.Contains($"tools/{tfm}/{packageRid}/Settings.json"));
}
}
public void It_can_restore_with_netcoreapp2_2()
{
TestProject toolProject = new TestProject()
{
Name = "TestTool" + nameof(It_can_restore_with_netcoreapp2_2),
IsSdkProject = true,
TargetFrameworks = "netcoreapp1.0",
IsExe = true
};
toolProject.AdditionalProperties.Add("PackageType", "DotnetCliTool");
var toolProjectInstance = _testAssetsManager.CreateTestProject(toolProject, identifier: toolProject.Name);
toolProjectInstance.Restore(Log, toolProject.Name, "/v:n");
var packCommand = new PackCommand(Log, Path.Combine(toolProjectInstance.TestRoot, toolProject.Name));
packCommand.Execute().Should().Pass();
string nupkgPath = Path.Combine(packCommand.ProjectRootPath, "bin", "Debug");
TestProject toolReferenceProject = new TestProject()
{
Name = "DotNetCliToolReferenceProject",
IsSdkProject = true,
IsExe = true,
TargetFrameworks = "netcoreapp1.0",
};
toolReferenceProject.DotNetCliToolReferences.Add(
new TestPackageReference(id: toolProject.Name,
version: ProjectToolVersion,
nupkgPath: null));
TestAsset toolReferenceProjectInstance = _testAssetsManager.CreateTestProject(toolReferenceProject, identifier: toolReferenceProject.Name);
DeleteFolder(Path.Combine(TestContext.Current.NuGetCachePath, toolProject.Name.ToLowerInvariant()));
DeleteFolder(Path.Combine(TestContext.Current.NuGetCachePath, ".tools", toolProject.Name.ToLowerInvariant()));
NuGetConfigWriter.Write(toolReferenceProjectInstance.TestRoot, NuGetConfigWriter.DotnetCoreBlobFeed, nupkgPath);
RestoreCommand restoreCommand =
toolReferenceProjectInstance.GetRestoreCommand(log: Log, relativePath: toolReferenceProject.Name);
var restoreResult = restoreCommand
.Execute("/v:n");
if (restoreResult.ExitCode != 0)
{
// retry once since it downloads from the web
toolReferenceProjectInstance.Restore(Log, toolReferenceProject.Name, "/v:n");
}
var assetsJsonPath = Path.Combine(TestContext.Current.NuGetCachePath,
".tools",
toolProject.Name.ToLowerInvariant(),
ProjectToolVersion,
ExpectedProjectToolRestoreTargetFrameworkMoniker,
"project.assets.json");
LockFile lockFile = LockFileUtilities.GetLockFile(assetsJsonPath, NullLogger.Instance);
lockFile.Targets.Single().TargetFramework
.Should().Be(NuGetFramework.Parse(ExpectedProjectToolRestoreTargetFrameworkMoniker),
"Restore target framework should be capped at netcoreapp2.2 due to moving away from project tools." +
"Even when SDK's TFM is higher and the project's TFM is netcoreapp1.0");
}
public void NoOpRestoreResult_IsLazy()
{
const string lockFileContent = @"{
""version"": 1,
""targets"": {
"".NETPlatform,Version=v5.0"": {
""System.Runtime/4.0.10-beta-23008"": {
""compile"": {
""ref/dotnet/System.Runtime.dll"": {}
}
}
}
},
""libraries"": {
""System.Runtime/4.0.10-beta-23008"": {
""sha512"": ""JkGp8sCzxxRY1GS+p1SEk8WcaT8pu++/5b94ar2i/RaUN/OzkcGP/6OLFUxUf1uar75pUvotpiMawVt1dCEUVA=="",
""type"": ""Package"",
""files"": [
""_rels/.rels"",
""System.Runtime.nuspec"",
""License.rtf"",
""ref/dotnet/System.Runtime.dll"",
""ref/net451/_._"",
""lib/net451/_._"",
""ref/win81/_._"",
""lib/win81/_._"",
""ref/netcore50/System.Runtime.dll"",
""package/services/metadata/core-properties/cdec43993f064447a2d882cbfd022539.psmdcp"",
""[Content_Types].xml""
]
}
},
""projectFileDependencyGroups"": {
"""": [
""System.Runtime >= 4.0.10-beta-*""
],
"".NETPlatform,Version=v5.0"": []
}
}
";
// Arrange
using (var td = TestDirectory.Create())
{
var path = Path.Combine(td, "project.lock.json");
File.WriteAllText(path, lockFileContent);
var logger = new TestLogger();
var result = new NoOpRestoreResult(
success: true,
lockFilePath: path,
new Lazy <LockFile>(() => LockFileUtilities.GetLockFile(path, logger)),
cacheFile: new CacheFile("NotSoRandomString"),
cacheFilePath: null,
projectStyle: ProjectStyle.Unknown,
elapsedTime: TimeSpan.MinValue);
// Act
var actual = result.LockFile;
// Assert
Assert.Equal(1, actual.Libraries.Count);
Assert.Equal("System.Runtime", actual.Libraries[0].Name);
}
}
void Execute(DirectoryAssemblyResolver resolver)
{
LogDebugMessage("ResolveAssemblies Task");
LogDebugMessage(" ReferenceAssembliesDirectory: {0}", ReferenceAssembliesDirectory);
LogDebugMessage(" I18nAssemblies: {0}", I18nAssemblies);
LogDebugMessage(" LinkMode: {0}", LinkMode);
LogDebugTaskItems(" Assemblies:", Assemblies);
LogDebugMessage(" ProjectAssetFile: {0}", ProjectAssetFile);
LogDebugMessage(" TargetMoniker: {0}", TargetMoniker);
foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
resolver.SearchDirectories.Add(dir);
}
var assemblies = new HashSet <string> ();
var topAssemblyReferences = new List <AssemblyDefinition> ();
var logger = new NuGetLogger((s) => {
LogDebugMessage("{0}", s);
});
LockFile lockFile = null;
if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
{
lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
}
try {
foreach (var assembly in Assemblies)
{
var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);
if (!resolver.SearchDirectories.Contains(assembly_path))
{
resolver.SearchDirectories.Add(assembly_path);
}
// Add each user assembly and all referenced assemblies (recursive)
var assemblyDef = resolver.Load(assembly.ItemSpec);
if (assemblyDef == null)
{
throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
}
if (MonoAndroidHelper.IsReferenceAssembly(assemblyDef))
{
// Resolve "runtime" library
var asmFullPath = Path.GetFullPath(assembly.ItemSpec);
if (lockFile != null)
{
assemblyDef = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, resolver, asmFullPath);
}
if (lockFile == null || assemblyDef == null)
{
LogWarning($"Ignoring {asmFullPath} as it is a Reference Assembly");
continue;
}
}
topAssemblyReferences.Add(assemblyDef);
assemblies.Add(Path.GetFullPath(assemblyDef.MainModule.FullyQualifiedName));
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return;
}
try {
foreach (var assembly in topAssemblyReferences)
{
AddAssemblyReferences(resolver, assemblies, assembly, null);
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return;
}
// Add I18N assemblies if needed
AddI18nAssemblies(resolver, assemblies);
ResolvedAssemblies = assemblies.Select(a => new TaskItem(a)).ToArray();
ResolvedSymbols = assemblies.Select(a => a + ".mdb").Where(a => File.Exists(a)).Select(a => new TaskItem(a)).ToArray();
ResolvedSymbols = ResolvedSymbols.Concat(
assemblies.Select(a => Path.ChangeExtension(a, "pdb"))
.Where(a => File.Exists(a) && Files.IsPortablePdb(a))
.Select(a => new TaskItem(a)))
.ToArray();
ResolvedFrameworkAssemblies = ResolvedAssemblies.Where(p => MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
ResolvedUserAssemblies = ResolvedAssemblies.Where(p => !MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
LogDebugTaskItems(" [Output] ResolvedAssemblies:", ResolvedAssemblies);
LogDebugTaskItems(" [Output] ResolvedUserAssemblies:", ResolvedUserAssemblies);
LogDebugTaskItems(" [Output] ResolvedFrameworkAssemblies:", ResolvedFrameworkAssemblies);
LogDebugTaskItems(" [Output] ResolvedDoNotPackageAttributes:", ResolvedDoNotPackageAttributes);
}
public void It_restores_multitargeted_net_framework_project_successfully(bool includeExplicitReference)
{
var testProject = new TestProject()
{
Name = "ProjectWithoutTargetingPackRef",
TargetFrameworks = "net471;net472;netcoreapp3.0",
};
TestAsset testAsset = null;
if (includeExplicitReference)
{
// Add explicit reference to assembly packs
testAsset = _testAssetsManager.CreateTestProject(testProject).WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var itemGroup = project.Root.Elements(ns + "ItemGroup").FirstOrDefault();
itemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"Microsoft.NETFramework.ReferenceAssemblies"),
new XAttribute("Version", $"1.0.0-preview.2")));
});
}
else
{
testAsset = _testAssetsManager.CreateTestProject(testProject);
}
string projectAssetsJsonPath = Path.Combine(
testAsset.Path,
testProject.Name,
"obj",
"project.assets.json");
var restoreCommand = testAsset.GetRestoreCommand(Log, relativePath: testProject.Name);
restoreCommand.Execute()
.Should()
.Pass()
.And
.NotHaveStdOutContaining("NETSDK1023");
LockFile lockFile = LockFileUtilities.GetLockFile(
projectAssetsJsonPath,
NullLogger.Instance);
var net471FrameworkLibrary = lockFile.GetTarget(NuGetFramework.Parse(".NETFramework,Version=v4.7.1"), null).Libraries.FirstOrDefault((file) => file.Name.Contains("net471"));
if (TestProject.ReferenceAssembliesAreInstalled(TargetDotNetFrameworkVersion.Version471) && !includeExplicitReference)
{
net471FrameworkLibrary.Should().BeNull();
}
else
{
net471FrameworkLibrary.Name.Should().Be("Microsoft.NETFramework.ReferenceAssemblies.net471");
net471FrameworkLibrary.Type.Should().Be("package");
}
var net472FrameworkLibrary = lockFile.GetTarget(NuGetFramework.Parse(".NETFramework,Version=v4.7.2"), null).Libraries.FirstOrDefault((file) => file.Name.Contains("net472"));
if (TestProject.ReferenceAssembliesAreInstalled(TargetDotNetFrameworkVersion.Version472) && !includeExplicitReference)
{
net472FrameworkLibrary.Should().BeNull();
}
else
{
net472FrameworkLibrary.Name.Should().Be("Microsoft.NETFramework.ReferenceAssemblies.net472");
net472FrameworkLibrary.Type.Should().Be("package");
}
}
private static ParsedProject CreateInternal(
string projectFile,
Arguments arguments,
BuildManager buildManager,
ILogger logger)
{
var relativeProjectFile = projectFile.Substring(arguments.Path.Length + 1);
try
{
var project = new Project(projectFile);
var assemblyFile = project.GetItems("IntermediateAssembly").FirstOrDefault()?.EvaluatedInclude;
if (string.IsNullOrEmpty(assemblyFile))
{
// Not all projects may produce an assembly. Just avoid these sorts of projects.
return(null);
}
var projectDirectory = Path.GetDirectoryName(projectFile);
var assemblyFileFullPath = Path.GetFullPath(Path.Combine(projectDirectory, assemblyFile));
var assemblyFileRelativePath = TryMakeRelative(arguments.Path, assemblyFileFullPath);
// Compile the assembly if needed
if (!File.Exists(assemblyFileFullPath))
{
if (arguments.CompileIfNeeded)
{
logger.LogDebug($"Assembly {assemblyFileRelativePath} does not exist. Compiling {relativeProjectFile}...");
var projectInstance = project.CreateProjectInstance();
// Compile usually requires a restore as well
if (arguments.RestoreIfNeeded)
{
var restoreResult = ExecuteRestore(projectInstance, buildManager);
if (restoreResult.OverallResult != BuildResultCode.Success)
{
logger.LogError($"Project failed to restore: {relativeProjectFile}");
return(null);
}
}
var compileResult = ExecuteCompile(projectInstance, buildManager);
if (compileResult.OverallResult != BuildResultCode.Success)
{
logger.LogError($"Project failed to compile: {relativeProjectFile}");
return(null);
}
}
else
{
// Can't analyze this project since it hasn't been built
logger.LogError($"Assembly {assemblyFileRelativePath} did not exist. Ensure you've previously built it, or set the --CompileIfNeeded flag. Project: {relativeProjectFile}");
return(null);
}
}
// Read metadata from the assembly, such as the assembly name and its references
string assemblyName;
var assemblyReferences = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
using (var stream = File.OpenRead(assemblyFileFullPath))
using (var peReader = new PEReader(stream))
{
var metadata = peReader.GetMetadataReader(MetadataReaderOptions.ApplyWindowsRuntimeProjections);
if (!metadata.IsAssembly)
{
logger.LogError($"{assemblyFileRelativePath} is not an assembly");
return(null);
}
assemblyName = metadata.GetString(metadata.GetAssemblyDefinition().Name);
foreach (var assemblyReferenceHandle in metadata.AssemblyReferences)
{
var reference = metadata.GetAssemblyReference(assemblyReferenceHandle);
var name = metadata.GetString(reference.Name);
if (!string.IsNullOrEmpty(name))
{
assemblyReferences.Add(name);
}
}
}
var references = project
.GetItems("Reference")
.Where(reference => !reference.UnevaluatedInclude.Equals("@(_SDKImplicitReference)", StringComparison.OrdinalIgnoreCase))
.Select(reference => reference.EvaluatedInclude)
.ToList();
var projectReferences = project
.GetItems("ProjectReference")
.Select(reference => new ProjectReference(Create(Path.GetFullPath(Path.Combine(projectDirectory, reference.EvaluatedInclude)), arguments, buildManager, logger), reference.UnevaluatedInclude))
.Where(projectReference => projectReference.Project != null)
.ToList();
var packageReferences = project
.GetItems("PackageReference")
.Select(reference => reference.EvaluatedInclude)
.ToList();
// Certain project types may require references simply to copy them to the output folder to satisfy transitive dependencies.
if (NeedsTransitiveAssemblyReferences(project))
{
projectReferences.ForEach(projectReference => assemblyReferences.UnionWith(projectReference.Project.AssemblyReferences));
}
// Collect package assemblies
var packageAssemblies = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
if (packageReferences.Count > 0)
{
var projectAssetsFile = project.GetPropertyValue("ProjectAssetsFile");
if (string.IsNullOrEmpty(projectAssetsFile))
{
logger.LogError($"Project with PackageReferences missing ProjectAssetsFile property: {relativeProjectFile}");
return(null);
}
// TODO: Combine with the restore above.
var projectAssetsFileFullPath = Path.GetFullPath(Path.Combine(projectDirectory, projectAssetsFile));
var projectAssetsFileRelativePath = TryMakeRelative(arguments.Path, projectAssetsFileFullPath);
if (!File.Exists(projectAssetsFileFullPath))
{
if (arguments.RestoreIfNeeded)
{
logger.LogDebug($"ProjectAssetsFile {projectAssetsFileRelativePath} did not exist. Restoring {relativeProjectFile}...");
var projectInstance = project.CreateProjectInstance();
var restoreResult = ExecuteRestore(projectInstance, buildManager);
if (restoreResult.OverallResult != BuildResultCode.Success)
{
logger.LogError($"Project failed to restore: {relativeProjectFile}");
return(null);
}
}
else
{
// Can't analyze this project since it hasn't been restored
logger.LogError($"ProjectAssetsFile {projectAssetsFileRelativePath} did not exist. Ensure you've previously built it, or set the --RestoreIfNeeded flag. Project: {relativeProjectFile}");
return(null);
}
}
var lockFile = LockFileUtilities.GetLockFile(projectAssetsFileFullPath, NullLogger.Instance);
if (lockFile == null)
{
logger.LogError($"{projectAssetsFileRelativePath} is not a valid assets file");
return(null);
}
var packageFolders = lockFile.PackageFolders.Select(item => item.Path).ToList();
var nuGetTargetMoniker = project.GetPropertyValue("NuGetTargetMoniker");
var runtimeIdentifier = project.GetPropertyValue("RuntimeIdentifier");
var nugetTarget = lockFile.GetTarget(NuGetFramework.Parse(nuGetTargetMoniker), runtimeIdentifier);
var nugetLibraries = nugetTarget.Libraries
.Where(nugetLibrary => nugetLibrary.Type.Equals("Package", StringComparison.OrdinalIgnoreCase))
.ToList();
// Compute the hierarchy of packages.
// Keys are packages and values are packages which depend on that package.
var nugetDependants = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
foreach (var nugetLibrary in nugetLibraries)
{
var packageId = nugetLibrary.Name;
foreach (var dependency in nugetLibrary.Dependencies)
{
if (!nugetDependants.TryGetValue(dependency.Id, out var parents))
{
parents = new List <string>();
nugetDependants.Add(dependency.Id, parents);
}
parents.Add(packageId);
}
}
// Get the transitive closure of assemblies included by each package
foreach (var nugetLibrary in nugetLibraries)
{
var nugetLibraryAssemblies = nugetLibrary.CompileTimeAssemblies
.Select(item => item.Path)
.Where(path => !path.EndsWith("_._", StringComparison.Ordinal)) // Ignore special packages
.Select(path =>
{
var packageFolderRelativePath = Path.Combine(nugetLibrary.Name, nugetLibrary.Version.ToNormalizedString(), path);
var fullPath = packageFolders
.Select(packageFolder => Path.Combine(packageFolder, packageFolderRelativePath))
.First(File.Exists);
return(System.Reflection.AssemblyName.GetAssemblyName(fullPath).Name);
})
.ToList();
// Walk up to add assemblies to all packages which directly or indirectly depend on this one.
var seenDependants = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var queue = new Queue <string>();
queue.Enqueue(nugetLibrary.Name);
while (queue.Count > 0)
{
var packageId = queue.Dequeue();
// Add this package's assemblies, if there are any
if (nugetLibraryAssemblies.Count > 0)
{
if (!packageAssemblies.TryGetValue(packageId, out var assemblies))
{
assemblies = new List <string>();
packageAssemblies.Add(packageId, assemblies);
}
assemblies.AddRange(nugetLibraryAssemblies);
}
// Recurse though dependants
if (nugetDependants.TryGetValue(packageId, out var dependants))
{
foreach (var dependant in dependants)
{
if (seenDependants.Add(dependant))
{
queue.Enqueue(dependant);
}
}
}
}
}
}
return(new ParsedProject
{
Name = projectFile,
AssemblyName = assemblyName,
AssemblyReferences = assemblyReferences,
References = references,
ProjectReferences = projectReferences,
PackageReferences = packageReferences,
PackageAssemblies = packageAssemblies,
});
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e)
{
logger.LogError($"Exception while trying to load: {relativeProjectFile}. Exception: {e}");
return(null);
}
#pragma warning restore CA1031 // Do not catch general exception types
}
/// <summary>
/// Creates an MSBuild properties file that specifies the full closure of packages with locked versions.
/// </summary>
/// <returns>A <see cref="ProjectRootElement"/> object that can be saved.</returns>
internal bool TryCreateProject(out ProjectRootElement project)
{
project = null;
if (!File.Exists(ProjectAssetsFile))
{
Log.LogError($"NuGet assets file '{ProjectAssetsFile}' does not exist.");
return(false);
}
// should item group be conditioned or items or metadata? Perhaps item condition should be considered and compared as well as an item could be conditioned. Consider the below scenarios. Since we are only parsing the assets file we need to consider the project file entries.
// <PackageReference Include="foo" Version="1.2.3" Condition="bar"/>
// <PackageReference Include="foo">
// <version>1.2.3</version>
// <version Condition="bar">1.2.3</version>
// </PackageReference>
// What about dependencies of packages that are conditioned? they should be conditioned as well.
HashSet <string> packagesToExclude = new HashSet <string>(PackagesToExclude?.Select(i => i.ItemSpec).Distinct() ?? Enumerable.Empty <string>(), StringComparer.OrdinalIgnoreCase);
project = ProjectRootElement.Create();
project.ToolsVersion = String.Empty;
ProjectPropertyElement wasImportedPropertyElement = project.AddProperty("NuGetDeterministicPropsWasImported", "true");
LockFile lockFile = LockFileUtilities.GetLockFile(ProjectAssetsFile, NullLogger.Instance);
bool crossTargeting = lockFile.PackageSpec.TargetFrameworks.Count > 1;
foreach (TargetFrameworkInformation targetFramework in lockFile.PackageSpec.TargetFrameworks)
{
HashSet <LockFileLibrary> addedLibraries = new HashSet <LockFileLibrary>();
ProjectItemGroupElement itemGroupElement = project.AddItemGroup();
if (crossTargeting)
{
itemGroupElement.Condition = $" '$(TargetFramework)' == '{targetFramework.FrameworkName.GetShortFolderName()}' ";
}
LockFileTarget target = lockFile.GetTarget(targetFramework.FrameworkName, runtimeIdentifier: null);
bool addedImplicitReference = false;
foreach (LibraryDependency libraryDependency in targetFramework.Dependencies.Where(i => !packagesToExclude.Contains(i.Name)))
{
if (libraryDependency.AutoReferenced)
{
if (ExcludeImplicitReferences)
{
continue;
}
addedImplicitReference = true;
}
LockFileLibrary library = lockFile.GetLibrary(libraryDependency);
if (library.Type.Equals("project", StringComparison.OrdinalIgnoreCase))
{
// if a csproj name matches a package id then nuget swaps in the csproj output instead of the package. Because of this we should skip adding the package as a locked package because it provides no value.
continue;
}
if (addedLibraries.Contains(library))
{
continue;
}
addedLibraries.Add(library);
LockFileTargetLibrary targetLibrary = target.GetTargetLibrary(libraryDependency.Name);
itemGroupElement.AddItem("PackageReference", targetLibrary.Name, GetPackageReferenceItemMetadata(library, libraryDependency));
foreach (LockFileLibrary dependency in targetLibrary.ResolveDependencies(lockFile, target).Where(i => !addedLibraries.Contains(i) && !packagesToExclude.Contains(i.Name)))
{
addedLibraries.Add(dependency);
itemGroupElement.AddItem("PackageReference", dependency.Name, GetPackageReferenceItemMetadata(dependency));
}
}
if (addedImplicitReference)
{
ProjectPropertyElement disableImplicitFrameworkReferencesPropertyElement = project.AddProperty("DisableImplicitFrameworkReferences", "true");
if (crossTargeting)
{
disableImplicitFrameworkReferencesPropertyElement.Condition = $" '$(TargetFramework)' == '{targetFramework.FrameworkName.GetShortFolderName()}' ";
}
}
}
ProjectImportElement beforeImportElement = project.CreateImportElement("Before.$(MSBuildThisFile)");
project.InsertAfterChild(beforeImportElement, wasImportedPropertyElement.Parent);
beforeImportElement.Condition = $"Exists('{beforeImportElement.Project}')";
ProjectImportElement afterImportElement = project.AddImport("After.$(MSBuildThisFile)");
afterImportElement.Condition = $"Exists('{afterImportElement.Project}')";
return(true);
}
public static LockFile GetLockFile(string lockFilePrefix)
{
string filePath = Path.Combine("LockFiles", $"{lockFilePrefix}.project.lock.json");
return(LockFileUtilities.GetLockFile(filePath, NullLogger.Instance));
}
private string GetOutput(string outputPath, string projectPath, GenerationType generationType, string contextName, string migrationIdentifier, string nameSpace)
{
var launchPath = _project.IsNetCore21OrHigher() ? DropNetCoreFiles() : DropFiles(outputPath);
//Fix for "Bad IL format" with .NET Core 3.0 - test again after release
if ((_project.IsNetCore30() || _project.IsNetCore31()) && outputPath.EndsWith(".exe"))
{
outputPath = outputPath.Remove(outputPath.Length - 4, 4);
outputPath += ".dll";
}
var startInfo = new ProcessStartInfo
{
FileName = Path.Combine(Path.GetDirectoryName(launchPath) ?? throw new InvalidOperationException(), "efpt.exe"),
Arguments = "\"" + outputPath + "\"",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
};
if (generationType == GenerationType.Ddl)
{
startInfo.Arguments = "ddl \"" + outputPath + "\"";
}
if (generationType == GenerationType.MigrationStatus)
{
startInfo.Arguments = "migrationstatus \"" + outputPath + "\"";
}
if (generationType == GenerationType.MigrationApply)
{
startInfo.Arguments = "migrate \"" + outputPath + "\" " + contextName;
}
if (generationType == GenerationType.MigrationAdd)
{
startInfo.Arguments = "addmigration \"" + outputPath + "\" " + "\"" + projectPath + "\" " + contextName + " " + migrationIdentifier + " " + nameSpace;
}
if (generationType == GenerationType.MigrationScript)
{
startInfo.Arguments = "scriptmigration \"" + outputPath + "\" " + contextName;
}
if (_project.IsNetCore())
{
//TODO Consider improving by getting Startup project!
// See EF Core .psm1 file
var fileRoot = Path.Combine(Path.GetDirectoryName(outputPath), Path.GetFileNameWithoutExtension(outputPath));
var efptPath = Path.Combine(launchPath, "efpt.dll");
var depsFile = fileRoot + ".deps.json";
var runtimeConfig = fileRoot + ".runtimeconfig.json";
var projectAssetsFile = _project.GetCspProperty("ProjectAssetsFile");
var runtimeFrameworkVersion = _project.GetCspProperty("RuntimeFrameworkVersion");
var dotNetParams = $"exec --depsfile \"{depsFile}\" ";
if (projectAssetsFile != null && File.Exists(projectAssetsFile))
{
var lockFile = LockFileUtilities.GetLockFile(projectAssetsFile, NuGet.Common.NullLogger.Instance);
if (lockFile != null)
{
foreach (var packageFolder in lockFile.PackageFolders)
{
var path = packageFolder.Path.TrimEnd('\\');
dotNetParams += $"--additionalprobingpath \"{path}\" ";
}
}
}
if (File.Exists(runtimeConfig))
{
dotNetParams += $"--runtimeconfig \"{runtimeConfig}\" ";
}
else if (runtimeFrameworkVersion != null)
{
dotNetParams += $"--fx-version {runtimeFrameworkVersion} ";
}
dotNetParams += $"\"{efptPath}\" ";
startInfo.WorkingDirectory = Path.GetDirectoryName(outputPath);
startInfo.FileName = "dotnet";
if (generationType == GenerationType.Ddl ||
generationType == GenerationType.MigrationApply ||
generationType == GenerationType.MigrationAdd ||
generationType == GenerationType.MigrationStatus)
{
startInfo.Arguments = dotNetParams + " " + startInfo.Arguments;
}
else
{
startInfo.Arguments = dotNetParams + " \"" + outputPath + "\"";
}
Debug.WriteLine(dotNetParams);
}
var standardOutput = new StringBuilder();
using (var process = System.Diagnostics.Process.Start(startInfo))
{
while (process != null && !process.HasExited)
{
standardOutput.Append(process.StandardOutput.ReadToEnd());
}
if (process != null)
{
standardOutput.Append(process.StandardOutput.ReadToEnd());
}
}
return(standardOutput.ToString());
}
void Execute(DirectoryAssemblyResolver resolver)
{
foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
resolver.SearchDirectories.Add(dir);
}
var assemblies = new Dictionary <string, ITaskItem> ();
var topAssemblyReferences = new List <AssemblyDefinition> ();
var logger = new NuGetLogger((s) => {
LogDebugMessage("{0}", s);
});
LockFile lockFile = null;
if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
{
lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
}
try {
foreach (var assembly in Assemblies)
{
var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);
if (!resolver.SearchDirectories.Contains(assembly_path))
{
resolver.SearchDirectories.Add(assembly_path);
}
// Add each user assembly and all referenced assemblies (recursive)
var assemblyDef = resolver.Load(assembly.ItemSpec);
if (assemblyDef == null)
{
throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
}
if (MonoAndroidHelper.IsReferenceAssembly(assemblyDef))
{
// Resolve "runtime" library
var asmFullPath = Path.GetFullPath(assembly.ItemSpec);
if (lockFile != null)
{
assemblyDef = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, resolver, asmFullPath);
}
if (lockFile == null || assemblyDef == null)
{
LogCodedWarning("XA0107", asmFullPath, 0, "Ignoring {0} as it is a Reference Assembly", asmFullPath);
continue;
}
}
topAssemblyReferences.Add(assemblyDef);
var taskItem = new TaskItem(assembly)
{
ItemSpec = Path.GetFullPath(assemblyDef.MainModule.FileName),
};
if (string.IsNullOrEmpty(taskItem.GetMetadata("ReferenceAssembly")))
{
taskItem.SetMetadata("ReferenceAssembly", taskItem.ItemSpec);
}
assemblies [assemblyDef.Name.Name] = taskItem;
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return;
}
try {
foreach (var assembly in topAssemblyReferences)
{
AddAssemblyReferences(resolver, assemblies, assembly, null);
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return;
}
// Add I18N assemblies if needed
AddI18nAssemblies(resolver, assemblies);
var mainapiLevel = MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion);
foreach (var item in api_levels.Where(x => mainapiLevel < x.Value))
{
var itemOSVersion = MonoAndroidHelper.SupportedVersions.GetFrameworkVersionFromApiLevel(item.Value);
Log.LogCodedWarning("XA0105", ProjectFile, 0,
"The $(TargetFrameworkVersion) for {0} ({1}) is greater than the $(TargetFrameworkVersion) for your project ({2}). " +
"You need to increase the $(TargetFrameworkVersion) for your project.", Path.GetFileName(item.Key), itemOSVersion, TargetFrameworkVersion);
}
var resolvedAssemblies = new List <ITaskItem> (assemblies.Count);
var resolvedSymbols = new List <ITaskItem> (assemblies.Count);
var resolvedFrameworkAssemblies = new List <ITaskItem> (assemblies.Count);
var resolvedUserAssemblies = new List <ITaskItem> (assemblies.Count);
foreach (var assembly in assemblies.Values)
{
var mdb = assembly + ".mdb";
var pdb = Path.ChangeExtension(assembly.ItemSpec, "pdb");
if (File.Exists(mdb))
{
resolvedSymbols.Add(new TaskItem(mdb));
}
if (File.Exists(pdb) && Files.IsPortablePdb(pdb))
{
resolvedSymbols.Add(new TaskItem(pdb));
}
resolvedAssemblies.Add(assembly);
if (MonoAndroidHelper.IsFrameworkAssembly(assembly.ItemSpec, checkSdkPath: true))
{
resolvedFrameworkAssemblies.Add(assembly);
}
else
{
resolvedUserAssemblies.Add(assembly);
}
}
ResolvedAssemblies = resolvedAssemblies.ToArray();
ResolvedSymbols = resolvedSymbols.ToArray();
ResolvedFrameworkAssemblies = resolvedFrameworkAssemblies.ToArray();
ResolvedUserAssemblies = resolvedUserAssemblies.ToArray();
ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
}
private void It_targets_the_right_framework(
string testIdentifier,
string targetFramework,
string runtimeFrameworkVersion,
bool selfContained,
bool isExe,
string expectedPackageVersion,
string expectedRuntimeVersion,
string extraMSBuildArguments = null)
{
string runtimeIdentifier = null;
if (selfContained)
{
runtimeIdentifier = EnvironmentInfo.GetCompatibleRid(targetFramework);
}
var testProject = new TestProject()
{
Name = "FrameworkTargetTest",
TargetFrameworks = targetFramework,
RuntimeFrameworkVersion = runtimeFrameworkVersion,
IsSdkProject = true,
IsExe = isExe,
RuntimeIdentifier = runtimeIdentifier
};
var extraArgs = extraMSBuildArguments?.Split(' ') ?? Array.Empty <string>();
var testAsset = _testAssetsManager.CreateTestProject(testProject, testIdentifier)
.Restore(Log, testProject.Name, extraArgs);
NuGetConfigWriter.Write(testAsset.TestRoot, NuGetConfigWriter.DotnetCoreBlobFeed);
var buildCommand = new BuildCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
buildCommand
.Execute(extraArgs)
.Should()
.Pass();
var outputDirectory = buildCommand.GetOutputDirectory(targetFramework, runtimeIdentifier: runtimeIdentifier);
if (isExe)
{
// Self-contained apps don't write a framework version to the runtimeconfig, so only check this for framework-dependent apps
if (!selfContained)
{
string runtimeConfigFile = Path.Combine(outputDirectory.FullName, testProject.Name + ".runtimeconfig.json");
string runtimeConfigContents = File.ReadAllText(runtimeConfigFile);
JObject runtimeConfig = JObject.Parse(runtimeConfigContents);
string actualRuntimeFrameworkVersion = ((JValue)runtimeConfig["runtimeOptions"]["framework"]["version"]).Value <string>();
actualRuntimeFrameworkVersion.Should().Be(expectedRuntimeVersion);
}
var runtimeconfigDevFileName = testProject.Name + ".runtimeconfig.dev.json";
outputDirectory.Should()
.HaveFile(runtimeconfigDevFileName);
string devruntimeConfigContents = File.ReadAllText(Path.Combine(outputDirectory.FullName, runtimeconfigDevFileName));
JObject devruntimeConfig = JObject.Parse(devruntimeConfigContents);
var additionalProbingPaths = ((JArray)devruntimeConfig["runtimeOptions"]["additionalProbingPaths"]).Values <string>();
// can't use Path.Combine on segments with an illegal `|` character
var expectedPath = $"{Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "store")}{Path.DirectorySeparatorChar}|arch|{Path.DirectorySeparatorChar}|tfm|";
additionalProbingPaths.Should().Contain(expectedPath);
}
LockFile lockFile = LockFileUtilities.GetLockFile(Path.Combine(buildCommand.ProjectRootPath, "obj", "project.assets.json"), NullLogger.Instance);
var target = lockFile.GetTarget(NuGetFramework.Parse(targetFramework), null);
var netCoreAppLibrary = target.Libraries.Single(l => l.Name == "Microsoft.NETCore.App");
netCoreAppLibrary.Version.ToString().Should().Be(expectedPackageVersion);
}
private void ExecuteCore()
{
DependencyContext context;
using (var depsStream = File.OpenRead(DepsFilePath))
{
context = new DependencyContextJsonReader().Read(depsStream);
}
var lockFile = LockFileUtilities.GetLockFile(AssetsFilePath, NullLogger.Instance);
if (lockFile == null)
{
throw new ArgumentException($"Could not load a LockFile at '{AssetsFilePath}'.", nameof(AssetsFilePath));
}
var manager = new RuntimeGraphManager();
var graph = manager.Collect(lockFile);
var expandedGraph = manager.Expand(graph, BaseRuntimeIdentifier);
var runtimeFiles = new List <RuntimeFile>();
var nativeFiles = new List <RuntimeFile>();
var resourceAssemblies = new List <ResourceAssembly>();
var platformManifest = new List <string>();
foreach (var library in context.RuntimeLibraries)
{
foreach (var file in library.RuntimeAssemblyGroups.SelectMany(g => g.RuntimeFiles))
{
var fileName = Path.GetFileName(file.Path);
var path = $"runtimes/{context.Target.Runtime}/lib/{TargetFramework}/{fileName}";
runtimeFiles.Add(
new RuntimeFile(
path,
file.AssemblyVersion,
file.FileVersion));
platformManifest.Add($"{fileName}|{FrameworkName}|{file.AssemblyVersion}|{file.FileVersion}");
}
foreach (var file in library.NativeLibraryGroups.SelectMany(g => g.RuntimeFiles))
{
var fileName = Path.GetFileName(file.Path);
var path = $"runtimes/{context.Target.Runtime}/native/{fileName}";
nativeFiles.Add(
new RuntimeFile(
path,
file.AssemblyVersion,
file.FileVersion));
if (!Version.TryParse(file.FileVersion, out var fileVersion))
{
fileVersion = new Version(0, 0, 0, 0);
}
platformManifest.Add($"{fileName}|{FrameworkName}||{fileVersion}");
}
resourceAssemblies.AddRange(
library.ResourceAssemblies);
}
var runtimePackageName = $"runtime.{context.Target.Runtime}.{FrameworkName}";
var runtimeLibrary = new RuntimeLibrary("package",
runtimePackageName,
FrameworkVersion,
string.Empty,
new[] { new RuntimeAssetGroup(string.Empty, runtimeFiles) },
new[] { new RuntimeAssetGroup(string.Empty, nativeFiles) },
resourceAssemblies,
Array.Empty <Dependency>(),
hashPath: null,
path: $"{runtimePackageName.ToLowerInvariant()}/{FrameworkVersion}",
serviceable: true);
var targetingPackLibrary = new RuntimeLibrary("package",
FrameworkName,
FrameworkVersion,
string.Empty,
Array.Empty <RuntimeAssetGroup>(),
Array.Empty <RuntimeAssetGroup>(),
resourceAssemblies,
new[] { new Dependency(runtimeLibrary.Name, runtimeLibrary.Version) },
hashPath: null,
path: $"{FrameworkName.ToLowerInvariant()}/{FrameworkVersion}",
serviceable: true);
context = new DependencyContext(
context.Target,
CompilationOptions.Default,
Array.Empty <CompilationLibrary>(),
new[] { targetingPackLibrary, runtimeLibrary },
expandedGraph
);
Directory.CreateDirectory(Path.GetDirectoryName(PlatformManifestOutputPath));
Directory.CreateDirectory(Path.GetDirectoryName(DepsFileOutputPath));
File.WriteAllLines(PlatformManifestOutputPath, platformManifest.OrderBy(n => n));
using (var depsStream = File.Create(DepsFileOutputPath))
{
new DependencyContextWriter().Write(context, depsStream);
}
}
