public int Lockfile(string projectOrLockfile, string target, string library)
{
// Locate the lock file
if (!string.Equals(Path.GetFileName(projectOrLockfile), LockFileFormat.LockFileName, StringComparison.Ordinal))
{
projectOrLockfile = Path.Combine(projectOrLockfile, LockFileFormat.LockFileName);
}
var lockfile = new LockFileFormat().Read(projectOrLockfile);
_log.LogInformation($"Viewing data from Lock File: {projectOrLockfile}");
// Attempt to locate the project
var projectPath = Path.Combine(Path.GetDirectoryName(projectOrLockfile), PackageSpec.PackageSpecFileName);
PackageSpec project = null;
if (File.Exists(projectPath))
{
project = JsonPackageSpecReader.GetPackageSpec(File.ReadAllText(projectPath), Path.GetFileName(Path.GetDirectoryName(projectPath)), projectPath);
}
if (string.IsNullOrEmpty(library))
{
return SummarizeLockfile(project, lockfile, target);
}
else
{
return LibraryDetail(project, lockfile, target, library);
}
}
public ImmutableArray <PackageReference> FindUnresolvedPackageReferences(ProjectFileInfo projectFile)
{
if (projectFile.PackageReferences.Length == 0)
{
return(ImmutableArray <PackageReference> .Empty);
}
// If the lock file does not exist, all of the package references are unresolved.
if (!File.Exists(projectFile.ProjectAssetsFile))
{
return(projectFile.PackageReferences);
}
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectFile.ProjectAssetsFile);
return(FindUnresolvedPackageReferencesInLockFile(projectFile, lockFile));
}
public void UWPRestore_ReadV1LockFile()
{
// Arrange
var expectedStream = GetResource("NuGet.Commands.FuncTest.compiler.resources.uwpBlankAppV1Original.json");
LockFile lockFile = null;
using (var reader = new StreamReader(expectedStream))
{
var format = new LockFileFormat();
// Act
lockFile = format.Parse(reader.ReadToEnd(), "c:\\project.lock.json");
}
// Assert
Assert.NotNull(lockFile);
}
public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory)
{
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory)));
var gacDependencyResolver = new GacDependencyResolver();
var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName);
if (File.Exists(projectLockJsonPath))
{
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectLockJsonPath);
nuGetDependencyProvider.ApplyLockFile(lockFile);
}
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
projectDepencyProvider,
nuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
nuGetDependencyProvider
});
}
public async Task UWPRestore_SystemDependencyVersionConflict()
{
// Arrange
var sources = new List <PackageSource>();
sources.Add(new PackageSource("https://api.nuget.org/v3/index.json"));
using (var packagesDir = TestDirectory.Create())
using (var projectDir = TestDirectory.Create())
{
var configJson = JObject.Parse(@"{
""dependencies"": {
""System.Text.Encoding"": ""4.0.10"",
""System.Collections"": ""4.0.11-beta-23225""
},
""frameworks"": {
""uap10.0"": {}
}
}");
var specPath = Path.Combine(projectDir, "TestProject", "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(configJson.ToString(), "TestProject", specPath);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(projectDir, "project.lock.json");
var lockFileFormat = new LockFileFormat();
var command = new RestoreCommand(request);
// Act
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFileJson = JObject.Parse(File.OpenText(request.LockFilePath).ReadToEnd());
// Assert
Assert.Equal(0, result.CompatibilityCheckResults.Sum(checkResult => checkResult.Issues.Count));
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
}
}
public async Task GivenAPackageDowngradeVerifyDowngradeWarningAsync()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
// Set up solution, project, and packages
var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot);
var projectA = SimpleTestProjectContext.CreateNETCore(
"a",
pathContext.SolutionRoot,
NuGetFramework.Parse("NETStandard1.5"));
var packageB = new SimpleTestPackageContext("b", "9.0.0");
var packageI1 = new SimpleTestPackageContext("i", "9.0.0");
var packageI2 = new SimpleTestPackageContext("i", "1.0.0");
packageB.Dependencies.Add(packageI1);
await SimpleTestPackageUtility.CreatePackagesAsync(pathContext.PackageSource, packageB, packageI1, packageI2);
projectA.AddPackageToAllFrameworks(packageB);
projectA.AddPackageToAllFrameworks(packageI2);
solution.Projects.Add(projectA);
solution.Create(pathContext.SolutionRoot);
// Act
var r = Util.Restore(pathContext, projectA.ProjectPath);
var output = r.Item2 + " " + r.Item3;
var reader = new LockFileFormat();
var lockFileObj = reader.Read(projectA.AssetsFileOutputPath);
// Assert
Assert.NotNull(lockFileObj);
Assert.Equal(1, lockFileObj.LogMessages.Count());
Assert.Contains("Detected package downgrade: i from 9.0.0 to 1.0.0",
lockFileObj.LogMessages.First().Message,
StringComparison.OrdinalIgnoreCase);
Assert.Contains("Detected package downgrade: i from 9.0.0 to 1.0.0",
output,
StringComparison.OrdinalIgnoreCase);
}
}
private void WriteLockFile(string dir, string libName, string version)
{
var lockFile = new LockFile
{
Islocked = false,
Libraries = new List <LockFileLibrary>
{
new LockFileLibrary
{
Name = libName,
Version = new NuGet.SemanticVersion(version),
Sha512 = "TestSha"
}
}
};
var lockFormat = new LockFileFormat();
lockFormat.Write($"{dir}/project.lock.json", lockFile);
}
public static async Task <PackageVersion> GetPackageVersion(string fullPath)
{
try
{
// Solution file: extract projects
var solutionDirectory = Path.GetDirectoryName(fullPath) ?? "";
var solution = Stride.Core.VisualStudio.Solution.FromFile(fullPath);
foreach (var project in solution.Projects)
{
if (project.TypeGuid == VisualStudio.KnownProjectTypeGuid.CSharp || project.TypeGuid == VisualStudio.KnownProjectTypeGuid.CSharpNewSystem)
{
var projectPath = project.FullPath;
var projectAssetsJsonPath = Path.Combine(Path.GetDirectoryName(projectPath), @"obj", LockFileFormat.AssetsFileName);
#if !STRIDE_LAUNCHER && !STRIDE_VSPACKAGE
if (!File.Exists(projectAssetsJsonPath))
{
var log = new Stride.Core.Diagnostics.LoggerResult();
await VSProjectHelper.RestoreNugetPackages(log, projectPath);
}
#endif
if (File.Exists(projectAssetsJsonPath))
{
var format = new LockFileFormat();
var projectAssets = format.Read(projectAssetsJsonPath);
foreach (var library in projectAssets.Libraries)
{
if ((library.Type == "package" || library.Type == "project") && (library.Name == "Stride.Engine" || library.Name == "Xenko.Engine"))
{
return(new PackageVersion((string)library.Version.ToString()));
}
}
}
}
}
}
catch (Exception e)
{
e.Ignore();
}
return(null);
}
public async Task UWPRestore_VerifySatellitePackagesAreCompatibleInPCL()
{
// Arrange
var sources = new List <PackageSource>();
sources.Add(new PackageSource("https://api.nuget.org/v3/index.json"));
using (var packagesDir = TestDirectory.Create())
using (var projectDir = TestDirectory.Create())
{
var configJson = JObject.Parse(@"{
""dependencies"": {
""Microsoft.AspNet.Mvc.de"": ""5.2.3""
},
""frameworks"": {
""net46"": {
}
}
}");
var specPath = Path.Combine(projectDir, "TestProject", "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(configJson.ToString(), "TestProject", specPath);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(projectDir, "project.lock.json");
var lockFileFormat = new LockFileFormat();
var command = new RestoreCommand(request);
// Act
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.Equal(0, result.CompatibilityCheckResults.Sum(checkResult => checkResult.Issues.Count));
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
Assert.Equal(5, result.GetAllInstalled().Count);
}
}
public void GenerateDepsJsonMethodDoesntOverwriteWhenDepsFileAlreadyExists()
{
var testInstance = TestAssets.Get(TestProjectName)
.CreateInstance()
.WithSourceFiles()
.WithRestoreFiles();
var repoDirectoriesProvider = new RepoDirectoriesProvider();
var nugetPackagesRoot = repoDirectoriesProvider.NugetPackages;
var toolPathCalculator = new ToolPathCalculator(nugetPackagesRoot);
var lockFilePath = toolPathCalculator.GetLockFilePath(
"dotnet-portable",
new NuGetVersion("1.0.0"),
s_toolPackageFramework);
var lockFile = new LockFileFormat().Read(lockFilePath);
var depsJsonFile = Path.Combine(
Path.GetDirectoryName(lockFilePath),
"dotnet-portable.deps.json");
if (File.Exists(depsJsonFile))
{
File.Delete(depsJsonFile);
}
File.WriteAllText(depsJsonFile, "temp");
var projectToolsCommandResolver = SetupProjectToolsCommandResolver();
projectToolsCommandResolver.GenerateDepsJsonFile(
lockFile,
s_toolPackageFramework,
depsJsonFile,
new SingleProjectInfo("dotnet-portable", "1.0.0", Enumerable.Empty <ResourceAssemblyInfo>()),
GetToolDepsJsonGeneratorProject());
File.ReadAllText(depsJsonFile).Should().Be("temp");
File.Delete(depsJsonFile);
}
public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory) {
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory)));
var gacDependencyResolver = new GacDependencyResolver();
var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName);
if (File.Exists(projectLockJsonPath)) {
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectLockJsonPath);
nuGetDependencyProvider.ApplyLockFile(lockFile);
}
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
projectDepencyProvider,
nuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
nuGetDependencyProvider
});
}
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path)
{
return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync(
path,
lockedToken =>
{
if (!File.Exists(path))
{
throw new GracefulException(string.Join(
Environment.NewLine,
string.Format(Resources.GetString("FileNotFound"), path),
Resources.GetString("ProjectNotRestoredOrRestoreFailed")));
}
var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path), Resources.GetString("CouldNotAccessAssetsFile"));
return lockFile;
},
CancellationToken.None));
}
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path)
{
if (!File.Exists(path))
{
throw new GracefulException(string.Join(
Environment.NewLine,
$"File not found `{path}`.",
"The project may not have been restored or restore failed - run `dotnet restore`"));
}
return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync(
path,
lockedToken =>
{
var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path));
return lockFile;
},
CancellationToken.None));
}
/// <summary>
/// Commits the lock file contained in <see cref="LockFile"/> and the MSBuild targets/props to
/// the local file system.
/// </summary>
/// <remarks>If <see cref="PreviousLockFile"/> and <see cref="LockFile"/> are identical
/// the file will not be written to disk.</remarks>
public virtual async Task CommitAsync(ILogger log, CancellationToken token)
{
// Write the lock file
var lockFileFormat = new LockFileFormat();
var isTool = ProjectStyle == ProjectStyle.DotnetCliTool;
// Commit the assets file to disk.
await CommitAssetsFileAsync(
lockFileFormat,
result : this,
log : log,
toolCommit : isTool,
token : token);
//Commit the cache file to disk
await CommitCacheFileAsync(
log : log,
toolCommit : isTool);
}
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path)
{
if (!File.Exists(path))
{
throw new GracefulException(string.Join(
Environment.NewLine,
string.Format(LocalizableStrings.FileNotFound, path),
LocalizableStrings.ProjectNotRestoredOrRestoreFailed));
}
return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync(
path,
lockedToken =>
{
var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path));
return lockFile;
},
CancellationToken.None));
}
private IReadOnlyList <CommandSettings> GetCommands()
{
try
{
var commands = new List <CommandSettings>();
var lockFile = new LockFileFormat().Read(PackageDirectory.WithFile(AssetsFileName).Value);
var library = FindLibraryInLockFile(lockFile);
ToolConfiguration configuration = DeserializeToolConfiguration(ToolSettingsFileName, library);
var entryPointFromLockFile = FindItemInTargetLibrary(library, configuration.ToolAssemblyEntryPoint);
if (entryPointFromLockFile == null)
{
throw new ToolConfigurationException(
string.Format(
CommonLocalizableStrings.MissingToolEntryPointFile,
configuration.ToolAssemblyEntryPoint,
configuration.CommandName));
}
// Currently only "dotnet" commands are supported
commands.Add(new CommandSettings(
configuration.CommandName,
"dotnet",
PackageDirectory
.WithSubDirectories(
Id.ToString(),
library.Version.ToNormalizedString())
.WithFile(entryPointFromLockFile.Path)));
return(commands);
}
catch (Exception ex) when(ex is UnauthorizedAccessException || ex is IOException)
{
throw new ToolConfigurationException(
string.Format(
CommonLocalizableStrings.FailedToRetrieveToolConfiguration,
ex.Message),
ex);
}
}
private LockFile GetAssetsFile(IPackTaskRequest <IMSBuildItem> request)
{
if (request.PackItem == null)
{
throw new PackagingException(NuGetLogCode.NU5028, Strings.NoPackItemProvided);
}
string assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName);
if (!File.Exists(assetsFilePath))
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileNotFound,
assetsFilePath));
}
// The assets file is necessary for project and package references. Pack should not do any traversal,
// so we leave that work up to restore (which produces the assets file).
var lockFileFormat = new LockFileFormat();
return(lockFileFormat.Read(assetsFilePath));
}
public bool TryGetLockFile(out LockFile lockFile)
{
lockFile = null;
var lockFilePath = GetLockFilePathFromProjectLockFileProperty() ??
GetLockFilePathFromIntermediateBaseOutputPath();
if (lockFilePath == null)
{
return(false);
}
if (!File.Exists(lockFilePath))
{
return(false);
}
lockFile = new LockFileFormat()
.ReadWithLock(lockFilePath)
.Result;
return(true);
}
public void PortablePublishWithLatestTFMUsesBundledAspNetCoreAppVersion()
{
var _testInstance = TestAssets.Get(AspNetTestProject)
.CreateInstance(identifier: LatestSupportedAspNetCoreAppVersion)
.WithSourceFiles();
string projectDirectory = _testInstance.Root.FullName;
string projectPath = Path.Combine(projectDirectory, $"{AspNetTestProject}.csproj");
var project = XDocument.Load(projectPath);
var ns = project.Root.Name.Namespace;
// Update TargetFramework to the right version of .NET Core
project.Root.Element(ns + "PropertyGroup")
.Element(ns + "TargetFramework")
.Value = "netcoreapp" + LatestSupportedAspNetCoreAppVersion;
project.Save(projectPath);
// Get the implicit version
new RestoreCommand()
.WithWorkingDirectory(projectDirectory)
.Execute()
.Should().Pass();
var assetsFilePath = Path.Combine(projectDirectory, "obj", "project.assets.json");
var assetsFile = new LockFileFormat().Read(assetsFilePath);
var restoredVersion = GetAspNetCoreAppVersion(assetsFile, portable: true);
restoredVersion.Should().NotBeNull();
var bundledVersionPath = Path.Combine(projectDirectory, ".BundledAspNetCoreVersion");
var bundledVersion = File.ReadAllText(bundledVersionPath).Trim();
restoredVersion.ToNormalizedString().Should().BeEquivalentTo(bundledVersion,
"The bundled aspnetcore versions set in Microsoft.NETCoreSdk.BundledVersions.props should be idenitical to the versions set in DependencyVersions.props." +
"Please update MSBuildExtensions.targets in this repo so these versions match.");
}
private void WriteLockFile(string projectLockFilePath, HashSet <Library> graphItems, NuGetv3LocalRepository repository)
{
var excludes = new[] { ".nuspec", ".nupkg", ".sha512" };
var lockFile = new LockFile();
lockFile.Islocked = false;
foreach (var item in graphItems.OrderBy(x => x.Name))
{
var package = repository.FindPackagesById(item.Name).FirstOrDefault(p => p.Version == item.Version);
if (package != null)
{
NuspecReader nuspecReader = null;
using (var stream = File.OpenRead(package.ManifestPath))
{
nuspecReader = new NuspecReader(stream);
}
var library = new LockFileLibrary();
library.Name = item.Name;
library.Version = item.Version;
library.FrameworkReferenceGroups = nuspecReader.GetFrameworkReferenceGroups().ToList();
library.ReferenceGroups = nuspecReader.GetReferenceGroups().ToList();
library.DependencyGroups = nuspecReader.GetDependencyGroups().ToList();
library.Files = Directory.EnumerateFiles(package.ExpandedPath, "*.*", SearchOption.AllDirectories)
.Where(path => !excludes.Contains(Path.GetExtension(path)))
.Select(path => path.Substring(package.ExpandedPath.Length).TrimStart(Path.DirectorySeparatorChar).Replace(Path.DirectorySeparatorChar, '/'))
.ToList();
lockFile.Libraries.Add(library);
}
}
var lockFileFormat = new LockFileFormat();
lockFileFormat.Write(projectLockFilePath, lockFile);
}
public void Generate_deps_json_method_doesnt_overwrite_when_deps_file_already_exists()
{
var testInstance = TestAssetsManager.CreateTestInstance(TestProjectName)
.WithLockFiles();
var context = ProjectContext.Create(Path.Combine(testInstance.Path, "project.json"), s_toolPackageFramework);
var nugetPackagesRoot = context.PackagesDirectory;
var toolPathCalculator = new ToolPathCalculator(nugetPackagesRoot);
var lockFilePath = toolPathCalculator.GetLockFilePath(
"dotnet-portable",
new NuGetVersion("1.0.0"),
s_toolPackageFramework);
var lockFile = new LockFileFormat().Read(lockFilePath);
var depsJsonFile = Path.Combine(
Path.GetDirectoryName(lockFilePath),
"dotnet-portable.deps.json");
if (File.Exists(depsJsonFile))
{
File.Delete(depsJsonFile);
}
File.WriteAllText(depsJsonFile, "temp");
var projectToolsCommandResolver = SetupProjectToolsCommandResolver();
projectToolsCommandResolver.GenerateDepsJsonFile(
lockFile,
depsJsonFile,
new SingleProjectInfo("dotnet-portable", "1.0.0", Enumerable.Empty <ResourceAssemblyInfo>()));
File.ReadAllText(depsJsonFile).Should().Be("temp");
File.Delete(depsJsonFile);
}
public void GivenAnUnknownPackageVerifyError()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
// Set up solution, project, and packages
var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot);
var projectA = SimpleTestProjectContext.CreateNETCore(
"a",
pathContext.SolutionRoot,
NuGetFramework.Parse("NETStandard1.5"));
var packageB = new SimpleTestPackageContext("b", "9.0.0");
projectA.AddPackageToAllFrameworks(packageB);
solution.Projects.Add(projectA);
solution.Create(pathContext.SolutionRoot);
// Act
var r = Util.Restore(pathContext, projectA.ProjectPath, expectedExitCode: 1);
var output = r.Item2 + " " + r.Item3;
var reader = new LockFileFormat();
var lockFileObj = reader.Read(projectA.AssetsFileOutputPath);
// Assert
Assert.NotNull(lockFileObj);
Assert.Equal(1, lockFileObj.LogMessages.Count());
Assert.Contains("Unable to find package b. No packages exist with this id in source(s): source",
lockFileObj.LogMessages.First().Message,
StringComparison.OrdinalIgnoreCase);
Assert.Contains("Unable to find package b. No packages exist with this id in source(s): source",
output,
StringComparison.OrdinalIgnoreCase);
}
}
internal void ItDoesNotRollForwardToTheLatestVersion(string packageName, string minorVersion)
{
var testProjectCreator = new TestProjectCreator()
{
PackageName = packageName,
MinorVersion = minorVersion,
};
var _testInstance = testProjectCreator.Create();
string projectDirectory = _testInstance.Root.FullName;
string projectPath = Path.Combine(projectDirectory, "TestAppSimple.csproj");
// Get the resolved version of .NET Core
new RestoreCommand()
.WithWorkingDirectory(projectDirectory)
.Execute()
.Should().Pass();
string assetsFilePath = Path.Combine(projectDirectory, "obj", "project.assets.json");
var assetsFile = new LockFileFormat().Read(assetsFilePath);
var versionInAssertsJson = GetPackageVersion(assetsFile, packageName);
versionInAssertsJson.Should().NotBeNull();
if (versionInAssertsJson.IsPrerelease && versionInAssertsJson.Patch == 0)
{
// if the bundled version is, for example, a prerelease of
// .NET Core 2.1.1, that we don't roll forward to that prerelease
// version for framework-dependent deployments.
return;
}
versionInAssertsJson.ToNormalizedString().Should().BeEquivalentTo(GetExpectedVersion(packageName, minorVersion));
}
public void GenerateDepsJsonMethodDoesntOverwriteWhenDepsFileAlreadyExists()
{
var testInstance = _testAssetsManager.CopyTestAsset(TestProjectName)
.WithSource()
.WithRepoGlobalPackages();
NuGetConfigWriter.Write(testInstance.Path, TestContext.Current.TestPackages);
testInstance.Restore(Log);
var toolPathCalculator = new ToolPathCalculator(TestContext.Current.TestGlobalPackagesFolder);
var lockFilePath = toolPathCalculator.GetLockFilePath(
"dotnet-portable",
new NuGetVersion("1.0.0"),
s_toolPackageFramework);
var lockFile = new LockFileFormat().Read(lockFilePath);
// NOTE: We must not use the real deps.json path here as it will interfere with tests running in parallel.
var depsJsonFile = Path.GetTempFileName();
File.WriteAllText(depsJsonFile, "temp");
var projectToolsCommandResolver = SetupProjectToolsCommandResolver();
projectToolsCommandResolver.GenerateDepsJsonFile(
lockFile,
s_toolPackageFramework,
depsJsonFile,
new SingleProjectInfo("dotnet-portable", "1.0.0", Enumerable.Empty <ResourceAssemblyInfo>()),
GetToolDepsJsonGeneratorProject());
File.ReadAllText(depsJsonFile).Should().Be("temp");
File.Delete(depsJsonFile);
}
private LockFile GetToolLockFile(
SingleProjectInfo toolLibrary,
string nugetPackagesRoot)
{
var lockFilePath = GetToolLockFilePath(toolLibrary, nugetPackagesRoot);
if (!File.Exists(lockFilePath))
{
return(null);
}
LockFile lockFile = null;
try
{
lockFile = new LockFileFormat().Read(lockFilePath);
}
catch (FileFormatException ex)
{
throw ex;
}
return(lockFile);
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_ReadLockFile()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var projectTargetFrameworkStr = "net45";
var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj");
var projectNames = new ProjectNames(
fullName: fullProjectPath,
uniqueName: Path.GetFileName(fullProjectPath),
shortName: Path.GetFileNameWithoutExtension(fullProjectPath),
customUniqueName: Path.GetFileName(fullProjectPath));
var vsProjectAdapter = new TestVSProjectAdapter(
fullProjectPath,
projectNames,
projectTargetFrameworkStr);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProject);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var packageContext = new SimpleTestPackageContext("packageA", "1.0.0");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
var projectLockFilePath = Path.Combine(randomProjectFolderPath, "packages.project1.lock.json");
File.Create(projectLockFilePath).Close();
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(projectLockFilePath));
// delete existing restore output files
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json"));
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project1.csproj.nuget.cache"));
// add a new package
var newPackageContext = new SimpleTestPackageContext("packageA", "1.0.1");
newPackageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(newPackageContext, packageSource);
// Act
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
var lockFilePath = Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json");
Assert.True(File.Exists(lockFilePath));
var lockFile = new LockFileFormat().Read(lockFilePath);
var resolvedVersion = lockFile.Targets.First().Libraries.First(library => library.Name.Equals("packageA", StringComparison.OrdinalIgnoreCase)).Version;
Assert.Equal("1.0.0", resolvedVersion.ToNormalizedString());
}
}
}
public async Task Project2ProjectInLockFile_VerifyProjectsReferencesInLibAndTargets()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""frameworks"": {
""net45"": {}
}
}";
var project2Json = @"
{
""version"": ""1.0.0"",
""frameworks"": {
""net45"": {}
}
}";
var project3Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
using (var packagesDir = TestDirectory.Create())
using (var workingDir = TestDirectory.Create())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3"));
project1.Create();
project2.Create();
project3.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json);
var project1Path = Path.Combine(project1.FullName, "project1.csproj");
var project2Path = Path.Combine(project2.FullName, "project2.csproj");
var project3Path = Path.Combine(project3.FullName, "project3.csproj");
File.WriteAllText(project1Path, string.Empty);
File.WriteAllText(project2Path, string.Empty);
File.WriteAllText(project3Path, string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var specPath3 = Path.Combine(project3.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project2", specPath2);
var spec3 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project3", specPath3);
var logger = new TestLogger();
var restoreContext = new RestoreArgs()
{
GlobalPackagesFolder = packagesDir,
Log = logger,
CacheContext = new SourceCacheContext()
};
// Modify specs for netcore
spec3 = spec3.WithTestRestoreMetadata();
spec3.FilePath = project3Path;
spec3.RestoreMetadata.ProjectPath = project3Path;
spec3.RestoreMetadata.ProjectUniqueName = project3Path;
spec2 = spec2.WithTestRestoreMetadata().WithTestProjectReference(spec3);
spec2.FilePath = project2Path;
spec2.RestoreMetadata.ProjectPath = project2Path;
spec2.RestoreMetadata.ProjectUniqueName = project2Path;
spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2);
spec1.FilePath = project1Path;
spec1.RestoreMetadata.ProjectPath = project1Path;
spec1.RestoreMetadata.ProjectUniqueName = project1Path;
var request = await ProjectJsonTestHelpers.GetRequestAsync(restoreContext, spec1, spec2, spec3);
request.LockFilePath = Path.Combine(project1.FullName, "project.assets.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
Assert.True(result.Success, logger.ShowMessages());
var lockFile = format.Read(request.LockFilePath, logger);
var project1Lib = lockFile.GetLibrary("project1", NuGetVersion.Parse("1.0.0"));
var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0"));
var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("1.0.0"));
var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project2")
.Single();
var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project3")
.Single();
// Assert
Assert.True(result.Success);
Assert.Equal(2, lockFile.Libraries.Count);
Assert.Equal("project", project2Lib.Type);
Assert.Equal("project", project3Lib.Type);
Assert.Equal("../project2/project2.csproj", project2Lib.Path);
Assert.Equal("../project3/project3.csproj", project3Lib.Path);
Assert.Equal("../project2/project2.csproj", project2Lib.MSBuildProject);
Assert.Equal("../project3/project3.csproj", project3Lib.MSBuildProject);
Assert.Equal(1, project2Target.Dependencies.Count);
Assert.Equal("project3", project2Target.Dependencies.Single().Id);
Assert.Equal("1.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString());
Assert.Equal(0, project3Target.Dependencies.Count);
Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework);
Assert.Equal(".NETFramework,Version=v4.5", project3Target.Framework);
}
}
public async Task Project2ProjectInLockFile_VerifyProjectsUnderProjectFileDependencyGroups_External()
{
// Arrange
var sources = new List <PackageSource>();
var projectJson = @"
{
""version"": ""1.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
using (var packagesDir = TestDirectory.Create())
using (var workingDir = TestDirectory.Create())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3"));
project1.Create();
project2.Create();
project3.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), projectJson);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), projectJson);
File.WriteAllText(Path.Combine(project3.FullName, "project.json"), projectJson);
File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.csproj"), string.Empty);
File.WriteAllText(Path.Combine(project3.FullName, "project3.csproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var specPath3 = Path.Combine(project3.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project2", specPath2);
var spec3 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project3", specPath3);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir, logger);
request.ExternalProjects.Add(new ExternalProjectReference(
"project1",
spec1,
Path.Combine(project1.FullName, "project1.xproj"),
new string[] { "project2" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project2",
spec2,
Path.Combine(project2.FullName, "project2.csproj"),
new string[] { "project3" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project3",
spec3,
Path.Combine(project3.FullName, "project3.csproj"),
new string[] { }));
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
var project1Lib = lockFile.GetLibrary("project1", NuGetVersion.Parse("1.0.0"));
var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0"));
var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("1.0.0"));
var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project2")
.Single();
var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project3")
.Single();
// Assert
Assert.True(result.Success);
Assert.Equal(2, lockFile.Libraries.Count);
Assert.Equal("project", project2Lib.Type);
Assert.Equal("project", project3Lib.Type);
Assert.Equal("../project2/project.json", project2Lib.Path);
Assert.Equal("../project3/project.json", project3Lib.Path);
Assert.Equal("../project2/project2.csproj", project2Lib.MSBuildProject);
Assert.Equal("../project3/project3.csproj", project3Lib.MSBuildProject);
Assert.Equal(1, project2Target.Dependencies.Count);
Assert.Equal("project3", project2Target.Dependencies.Single().Id);
Assert.Equal("1.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString());
Assert.Equal(0, project3Target.Dependencies.Count);
Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework);
Assert.Equal(".NETFramework,Version=v4.5", project3Target.Framework);
}
}
public async Task Project2ProjectInLockFile_VerifySnapshotVersions()
{
// Arrange
var sources = new List <PackageSource>();
var projectJson = @"
{
""version"": ""2.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
var project2Json = @"
{
""version"": ""2.0.0-*"",
""description"": ""Proj2 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""dependencies"": {
""project3"": ""2.0.0-*""
},
""frameworks"": {
""net45"": {
}
}
}";
var project3Json = @"
{
""version"": ""2.0.0-*"",
""description"": ""Proj3 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
var globalJson = @"
{
""projects"": [
""projects""
]
}";
using (var packagesDir = TestDirectory.Create())
using (var workingDir = TestDirectory.Create())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3"));
project1.Create();
project2.Create();
project3.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), projectJson);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json);
File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson);
File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project3.xproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var specPath3 = Path.Combine(project3.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var spec3 = JsonPackageSpecReader.GetPackageSpec(project3Json, "project3", specPath3);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir, logger);
request.ExternalProjects.Add(new ExternalProjectReference(
"project1",
spec1,
Path.Combine(project1.FullName, "project1.csproj"),
new string[] { "project2" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project2",
spec2,
Path.Combine(project2.FullName, "project2.xproj"),
new string[] { "project3" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project3",
spec3,
Path.Combine(project2.FullName, "project3.xproj"),
new string[] { }));
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("2.0.0"));
var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("2.0.0"));
var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Single(lib => lib.Name == "project2");
var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Single(lib => lib.Name == "project3");
// Assert
Assert.True(result.Success);
Assert.Equal("2.0.0", project2Target.Version.ToString());
Assert.Equal("2.0.0", project3Target.Version.ToString());
Assert.Equal("2.0.0", project2Lib.Version.ToString());
Assert.Equal("2.0.0", project3Lib.Version.ToString());
Assert.Equal("2.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString());
}
}
private void UpdateLockFile(PublishRoot root)
{
var lockFileFormat = new LockFileFormat();
string lockFilePath;
if (root.NoSource)
{
lockFilePath = Path.Combine(TargetPath, "root", LockFileFormat.LockFileName);
}
else
{
lockFilePath = Path.Combine(TargetPath, LockFileFormat.LockFileName);
}
LockFile lockFile;
if (File.Exists(lockFilePath))
{
lockFile = lockFileFormat.Read(lockFilePath);
}
else
{
lockFile = new LockFile
{
Islocked = false
};
var project = GetCurrentProject();
// Restore dependency groups for future lockfile validation
lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
string.Empty,
project.Dependencies.Select(x => x.LibraryRange.ToString())));
foreach (var frameworkInfo in project.GetTargetFrameworks())
{
lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
frameworkInfo.FrameworkName.ToString(),
frameworkInfo.Dependencies.Select(x => x.LibraryRange.ToString())));
}
}
if (root.NoSource)
{
// The dependency group shared by all frameworks should only contain the main nupkg (i.e. entrypoint)
lockFile.ProjectFileDependencyGroups.RemoveAll(g => string.IsNullOrEmpty(g.FrameworkName));
lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
string.Empty,
new[] { _libraryDescription.LibraryRange.ToString() }));
}
var repository = new PackageRepository(root.TargetPackagesPath);
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
// For dependency projects that were published to nupkgs
// Add them to lockfile to ensure the contents of lockfile are still valid
using (var sha512 = SHA512.Create())
{
foreach (var publishProject in root.Projects.Where(p => p.IsPackage))
{
var packageInfo = repository.FindPackagesById(publishProject.Name)
.SingleOrDefault();
if (packageInfo == null)
{
root.Reports.Information.WriteLine("Unable to locate published package {0} in {1}",
publishProject.Name.Yellow(),
repository.RepositoryRoot);
continue;
}
var package = packageInfo.Package;
var nupkgPath = resolver.GetPackageFilePath(package.Id, package.Version);
var project = publishProject.GetCurrentProject();
lockFile.Libraries.Add(LockFileUtils.CreateLockFileLibraryForProject(
project,
package,
sha512,
project.GetTargetFrameworks().Select(f => f.FrameworkName),
resolver));
}
}
lockFileFormat.Write(lockFilePath, lockFile);
}
protected IEnumerable <RuntimeLibrary> GetNugetReferences(string projectFilePath, Project project)
{
Logger.WriteInfo("Adding nuget references.");
ICollection <RuntimeLibrary> runtimeLibraries = new List <RuntimeLibrary>();
LockFileFormat lockFileFormat = new LockFileFormat();
string lockFileFilePath = Path.Combine(Path.GetDirectoryName(projectFilePath),
project.GetPropertyValue(PropertyNames.ProjectAssetsFile));
if (!File.Exists(lockFileFilePath))
{
Logger.WriteError($"Lock file {lockFileFilePath} not found. Run dotnet restore before executing Automaty.");
throw new AutomatyException();
}
LockFile lockFile = lockFileFormat.Read(lockFileFilePath);
string targetFramework = project.GetPropertyValue(PropertyNames.TargetFramework);
if (string.IsNullOrEmpty(targetFramework))
{
Logger.WriteDebug("Multi targeting project assembly detected.");
targetFramework = GetSuitableTargetFramework(project.GetPropertyValue(PropertyNames.TargetFrameworks));
Logger.WriteDebug($"Using target framework {targetFramework}.");
}
LockFileTarget lockFileTarget = lockFile.GetTarget(NuGetUtils.ParseFrameworkName(targetFramework), string.Empty);
NuGetPackageResolver nuGetPackageResolver =
NuGetPackageResolver.CreateResolver(lockFile, Path.GetDirectoryName(projectFilePath));
// Add nuget references
foreach (LockFileTargetLibrary library in lockFileTarget.Libraries)
{
if (library.Type != LibraryType.Package)
{
continue;
}
string packageDirectory = nuGetPackageResolver.GetPackageDirectory(library.Name, library.Version);
foreach (LockFileItem file in library.RuntimeAssemblies.Where(file => !NuGetUtils.IsPlaceholderFile(file.Path)))
{
string filePath = Path.GetFullPath(Path.Combine(packageDirectory, file.Path));
Logger.WriteDebug($"Adding \"{filePath}\".");
runtimeLibraries.Add(new RuntimeLibrary
{
Name = library.Name,
DirectoryName = Path.GetDirectoryName(filePath),
FileName = Path.GetFileName(filePath)
});
}
}
return(runtimeLibraries);
}
private SemanticVersion ResolvePackageVersion(string projectFile)
{
var projectFolder = Path.GetDirectoryName(projectFile);
var projectLockFile = Path.Combine(projectFolder, LockFileFormat.LockFileName);
if (!File.Exists(projectLockFile))
{
_reports.WriteError("The project.lock.json file is missing. Restore the packages to generate it.");
return null;
}
var lockFileReader = new LockFileFormat();
var lockFile = lockFileReader.Read(projectLockFile);
var librariesForPackage = lockFile
?.Libraries
.Where(lib => string.Equals(_packageId, lib.Name, StringComparison.OrdinalIgnoreCase));
// Projects can reference multiple versions of the same library
if (librariesForPackage.Count() > 1)
{
_reports.WriteError($"The project references multiple versions of the '{_packageId}'.");
return null;
}
var packageVersion = librariesForPackage.FirstOrDefault()?.Version;
if (packageVersion == null)
{
_reports.WriteError($"The project is not referencing the '{_packageId}' package. Sources can be retrieved only for packages used by the project.");
return null;
}
return packageVersion;
}
private bool PrunePackages(PublishRoot root)
{
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
// Special cases (for backwards compat)
var specialFolders = new List<string> {
"native",
"InteropAssemblies",
"redist",
"runtimes"
};
if (!root.NoSource)
{
// 'shared' folder is build time dependency, so we only copy it when deploying with source
specialFolders.Add("shared");
}
var lockFilePath = Path.GetFullPath(Path.Combine(ApplicationBasePath, LockFileFormat.LockFileName));
var format = new LockFileFormat();
root.LockFile = format.Read(lockFilePath);
var keep = new HashSet<string>();
foreach (var target in root.LockFile.Targets)
{
foreach (var library in target.Libraries)
{
var packagesDir = resolver.GetInstallPath(library.Name, library.Version);
var manifest = resolver.GetManifestFilePath(library.Name, library.Version);
keep.Add(manifest);
foreach (var path in library.RuntimeAssemblies)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var path in library.CompileTimeAssemblies)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var path in library.NativeLibraries)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var path in library.ResourceAssemblies)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var specialFolder in specialFolders)
{
var specialFolderPath = CombinePath(packagesDir, specialFolder);
if (!Directory.Exists(specialFolderPath))
{
continue;
}
keep.AddRange(Directory.EnumerateFiles(specialFolderPath, "*.*", SearchOption.AllDirectories));
}
}
}
foreach (var package in root.Packages)
{
var packageDir = resolver.GetInstallPath(package.Library.Name, package.Library.Version);
var packageFiles = Directory.EnumerateFiles(packageDir, "*.*", SearchOption.AllDirectories);
foreach (var file in packageFiles)
{
if (!keep.Contains(file))
{
File.Delete(file);
}
}
root.Operations.DeleteEmptyFolders(packageDir);
}
return true;
}
private void PurgeOrphanPackages()
{
_reports.Verbose.WriteLine("Removing orphaned packages...");
// Find the packages still used by the command scripts
var applicationPackagesStillUsed = _commandsRepo.Commands
.Select(cmd => _commandsRepo.FindCommandOwner(cmd))
.Distinct();
// Get all the installed packages
var packagesRepo = new PackageRepository(
_commandsRepo.PackagesRoot,
caseSensitivePackagesName: false);
// Key = package<id, version>, Value = bool (true if used, false otherwise)
var usedPackages = packagesRepo
.GetAllPackages()
.SelectMany(pack => pack.Value)
.ToDictionary(
pack => pack,
_ => false);
var lockFileFormat = new LockFileFormat();
// Mark all the packages still in used by using the dependencies in the lock file
foreach(var applicationPackage in applicationPackagesStillUsed)
{
var appLockFileFullPath = Path.Combine(
_commandsRepo.PackagesRoot.Root,
_commandsRepo.PathResolver.GetPackageDirectory(applicationPackage.Id, applicationPackage.Version),
InstallBuilder.CommandsFolderName,
LockFileFormat.LockFileName);
if (!File.Exists(appLockFileFullPath))
{
_reports.Verbose.WriteLine("Lock file {0} not found. This package will be removed if it is not used by another application", appLockFileFullPath);
// The lock file is missing, probably the app is not installed correctly
// unless someone else is using it, we'll remove it
continue;
}
var lockFile = lockFileFormat.Read(appLockFileFullPath);
foreach(var dependency in lockFile.PackageLibraries)
{
var dependencyPackage = new NuGet.PackageInfo(
_commandsRepo.PackagesRoot,
dependency.Name,
dependency.Version,
null,
null);
if (usedPackages.ContainsKey(dependencyPackage))
{
// Mark the dependency as used
usedPackages[dependencyPackage] = true;
}
}
}
// Now it's time to remove those unused packages
var unusedPackages = usedPackages
.Where(pack => !pack.Value)
.Select(pack => pack.Key);
foreach (var package in unusedPackages)
{
packagesRepo.RemovePackage(package);
_reports.Verbose.WriteLine("Removed orphaned package: {0} {1}", package.Id, package.Version);
}
}
public void ItRollsForwardToTheLatestVersion(string minorVersion)
{
var _testInstance = TestAssets.Get(AspNetTestProject)
.CreateInstance(identifier: minorVersion)
.WithSourceFiles();
string projectDirectory = _testInstance.Root.FullName;
string projectPath = Path.Combine(projectDirectory, $"{AspNetTestProject}.csproj");
var project = XDocument.Load(projectPath);
var ns = project.Root.Name.Namespace;
// Update TargetFramework to the right version of .NET Core
project.Root.Element(ns + "PropertyGroup")
.Element(ns + "TargetFramework")
.Value = "netcoreapp" + minorVersion;
var rid = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
// Set RuntimeIdentifier to opt in to roll-forward behavior
project.Root.Element(ns + "PropertyGroup")
.Add(new XElement(ns + "RuntimeIdentifier", rid));
project.Save(projectPath);
// Get the version rolled forward to
new RestoreCommand()
.WithWorkingDirectory(projectDirectory)
.Execute()
.Should().Pass();
string assetsFilePath = Path.Combine(projectDirectory, "obj", "project.assets.json");
var assetsFile = new LockFileFormat().Read(assetsFilePath);
var rolledForwardVersion = GetAspNetCoreAppVersion(assetsFile);
rolledForwardVersion.Should().NotBeNull();
if (rolledForwardVersion.IsPrerelease)
{
// If this version of .NET Core is still prerelease, then:
// - Floating the patch by adding ".*" to the major.minor version won't work, but
// - There aren't any patches to roll-forward to, so we skip testing this until the version
// leaves prerelease.
return;
}
// Float the RuntimeFrameworkVersion to get the latest version of the runtime available from feeds
Directory.Delete(Path.Combine(projectDirectory, "obj"), true);
project.Root.Element(ns + "PropertyGroup")
.Add(new XElement(ns + "RuntimeFrameworkVersion", $"{minorVersion}.*"));
project.Save(projectPath);
new RestoreCommand()
.WithWorkingDirectory(projectDirectory)
.Execute()
.Should().Pass();
var floatedAssetsFile = new LockFileFormat().Read(assetsFilePath);
var floatedVersion = GetAspNetCoreAppVersion(floatedAssetsFile);
floatedVersion.Should().NotBeNull();
rolledForwardVersion.ToNormalizedString().Should().BeEquivalentTo(floatedVersion.ToNormalizedString(),
"the latest patch version properties in Microsoft.NETCoreSdk.BundledVersions.props need to be updated " +
"(see MSBuildExtensions.targets in this repo)");
}
public async Task<RestoreResult> ExecuteAsync(RestoreRequest request)
{
if (request.Project.TargetFrameworks.Count == 0)
{
_log.LogError("The project does not specify any target frameworks!");
return new RestoreResult(success: false, restoreGraphs: Enumerable.Empty<RestoreTargetGraph>());
}
var projectLockFilePath = string.IsNullOrEmpty(request.LockFilePath) ?
Path.Combine(request.Project.BaseDirectory, LockFileFormat.LockFileName) :
request.LockFilePath;
_log.LogInformation($"Restoring packages for '{request.Project.FilePath}'");
_log.LogWarning("TODO: Read and use lock file");
// Load repositories
var projectResolver = new PackageSpecResolver(request.Project);
var nugetRepository = Repository.Factory.GetCoreV3(request.PackagesDirectory);
var context = new RemoteWalkContext();
ExternalProjectReference exterenalProjectReference = null;
if (request.ExternalProjects.Any())
{
exterenalProjectReference = new ExternalProjectReference(
request.Project.Name,
request.Project.FilePath,
request.ExternalProjects.Select(p => p.Name));
}
context.ProjectLibraryProviders.Add(
new LocalDependencyProvider(
new PackageSpecReferenceDependencyProvider(projectResolver, exterenalProjectReference)));
if (request.ExternalProjects != null)
{
context.ProjectLibraryProviders.Add(
new LocalDependencyProvider(
new ExternalProjectReferenceDependencyProvider(request.ExternalProjects)));
}
context.LocalLibraryProviders.Add(
new SourceRepositoryDependencyProvider(nugetRepository, _log));
foreach (var provider in request.Sources.Select(s => CreateProviderFromSource(s, request.NoCache)))
{
context.RemoteLibraryProviders.Add(provider);
}
var remoteWalker = new RemoteDependencyWalker(context);
var projectRange = new LibraryRange()
{
Name = request.Project.Name,
VersionRange = new VersionRange(request.Project.Version),
TypeConstraint = LibraryTypes.Project
};
// Resolve dependency graphs
var frameworks = request.Project.TargetFrameworks.Select(f => f.FrameworkName).ToList();
var graphs = new List<RestoreTargetGraph>();
var frameworkTasks = new List<Task<RestoreTargetGraph>>();
foreach (var framework in frameworks)
{
frameworkTasks.Add(WalkDependencies(projectRange, framework, remoteWalker, context));
}
graphs.AddRange(await Task.WhenAll(frameworkTasks));
if (graphs.Any(g => g.InConflict))
{
_log.LogError("Failed to resolve conflicts");
return new RestoreResult(success: false, restoreGraphs: graphs);
}
// Install the runtime-agnostic packages
var allInstalledPackages = new HashSet<LibraryIdentity>();
var localRepository = new NuGetv3LocalRepository(request.PackagesDirectory, checkPackageIdCase: false);
await InstallPackages(graphs, request.PackagesDirectory, allInstalledPackages, request.MaxDegreeOfConcurrency);
// Resolve runtime dependencies
var runtimeGraphs = new List<RestoreTargetGraph>();
if (request.Project.RuntimeGraph.Runtimes.Count > 0)
{
var runtimeTasks = new List<Task<RestoreTargetGraph[]>>();
foreach (var graph in graphs)
{
runtimeTasks.Add(WalkRuntimeDependencies(projectRange, graph, request.Project.RuntimeGraph, remoteWalker, context, localRepository));
}
foreach (var runtimeSpecificGraphs in await Task.WhenAll(runtimeTasks))
{
runtimeGraphs.AddRange(runtimeSpecificGraphs);
}
graphs.AddRange(runtimeGraphs);
if (runtimeGraphs.Any(g => g.InConflict))
{
_log.LogError("Failed to resolve conflicts");
return new RestoreResult(success: false, restoreGraphs: graphs);
}
// Install runtime-specific packages
await InstallPackages(runtimeGraphs, request.PackagesDirectory, allInstalledPackages, request.MaxDegreeOfConcurrency);
}
else
{
_log.LogVerbose("Skipping runtime dependency walk, no runtimes defined in project.json");
}
// Build the lock file
var repository = new NuGetv3LocalRepository(request.PackagesDirectory, checkPackageIdCase: false);
var lockFile = CreateLockFile(request.Project, graphs, repository);
var lockFileFormat = new LockFileFormat();
lockFileFormat.Write(projectLockFilePath, lockFile);
// Generate Targets/Props files
WriteTargetsAndProps(request.Project, graphs, repository);
return new RestoreResult(true, graphs, lockFile);
}
private void WriteLockFile(string dir, string libName, string version)
{
var lockFile = new LockFile
{
Islocked = false,
Libraries = new List<LockFileLibrary>
{
new LockFileLibrary
{
Name = libName,
Version = new NuGet.SemanticVersion(version),
Sha512 = "TestSha"
}
}
};
var lockFormat = new LockFileFormat();
lockFormat.Write($"{dir}/project.lock.json", lockFile);
}
public PackageBuilder GetPackageBuilder(IPackTaskRequest <IMSBuildItem> request)
{
// Load the assets JSON file produced by restore.
var assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName);
if (!File.Exists(assetsFilePath))
{
throw new PackagingException(NuGetLogCode.NU5023, string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileNotFound,
assetsFilePath));
}
var builder = new PackageBuilder(request.Deterministic)
{
Id = request.PackageId,
Description = request.Description,
Title = request.Title,
Copyright = request.Copyright,
ReleaseNotes = request.ReleaseNotes,
RequireLicenseAcceptance = request.RequireLicenseAcceptance,
PackageTypes = ParsePackageTypes(request)
};
if (request.DevelopmentDependency)
{
builder.DevelopmentDependency = true;
}
if (request.PackageVersion != null)
{
NuGetVersion version;
if (!NuGetVersion.TryParse(request.PackageVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5024, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidPackageVersion,
request.PackageVersion));
}
builder.Version = version;
}
else
{
builder.Version = new NuGetVersion("1.0.0");
}
if (request.Authors != null)
{
builder.Authors.AddRange(request.Authors);
}
if (request.Tags != null)
{
builder.Tags.AddRange(request.Tags);
}
Uri tempUri;
if (Uri.TryCreate(request.LicenseUrl, UriKind.Absolute, out tempUri))
{
builder.LicenseUrl = tempUri;
}
if (Uri.TryCreate(request.ProjectUrl, UriKind.Absolute, out tempUri))
{
builder.ProjectUrl = tempUri;
}
if (Uri.TryCreate(request.IconUrl, UriKind.Absolute, out tempUri))
{
builder.IconUrl = tempUri;
}
if (!string.IsNullOrEmpty(request.RepositoryUrl) || !string.IsNullOrEmpty(request.RepositoryType))
{
builder.Repository = new RepositoryMetadata(
request.RepositoryType,
request.RepositoryUrl,
request.RepositoryBranch,
request.RepositoryCommit);
}
builder.LicenseMetadata = BuildLicenseMetadata(request);
builder.Icon = request.PackageIcon;
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5022, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
builder.MinClientVersion = version;
}
// The assets file is necessary for project and package references. Pack should not do any traversal,
// so we leave that work up to restore (which produces the assets file).
var lockFileFormat = new LockFileFormat();
var assetsFile = lockFileFormat.Read(assetsFilePath);
if (assetsFile.PackageSpec == null)
{
throw new PackagingException(NuGetLogCode.NU5025, string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileDoesNotHaveValidPackageSpec,
assetsFilePath));
}
var projectRefToVersionMap = new Dictionary <string, string>(PathUtility.GetStringComparerBasedOnOS());
if (request.ProjectReferencesWithVersions != null && request.ProjectReferencesWithVersions.Any())
{
projectRefToVersionMap = request
.ProjectReferencesWithVersions
.ToDictionary(msbuildItem => msbuildItem.Identity,
msbuildItem => msbuildItem.GetProperty("ProjectVersion"), PathUtility.GetStringComparerBasedOnOS());
}
var nuGetFrameworkComparer = new NuGetFrameworkFullComparer();
var frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(nuGetFrameworkComparer);
if (request.FrameworksWithSuppressedDependencies != null && request.FrameworksWithSuppressedDependencies.Any())
{
frameworksWithSuppressedDependencies =
new HashSet <NuGetFramework>(request.FrameworksWithSuppressedDependencies
.Select(t => NuGetFramework.Parse(t.Identity)).ToList(), nuGetFrameworkComparer);
}
PopulateProjectAndPackageReferences(builder,
assetsFile,
projectRefToVersionMap,
frameworksWithSuppressedDependencies);
PopulateFrameworkAssemblyReferences(builder, request);
PopulateFrameworkReferences(builder, assetsFile);
return(builder);
}
private static void Process(FileInfo file)
{
var json = JObject.Parse(File.ReadAllText(file.FullName));
var format = new LockFileFormat();
var lockFile = format.Read(Path.Combine(file.DirectoryName, "project.lock.json"));
var projects = new HashSet<string>();
foreach (var lib in lockFile.Libraries)
{
if (lib.Type == "project")
{
projects.Add(lib.Name);
}
}
var dependencies = new List<JProperty>();
var rootDeps = json["dependencies"] as JObject;
if (rootDeps != null)
{
foreach (var dep in rootDeps.Properties())
{
dependencies.Add(dep);
}
}
var frameworks = json["frameworks"] as JObject;
if (frameworks != null)
{
foreach (var fw in frameworks.Properties())
{
var fwDeps = fw.Value["dependencies"] as JObject;
if (fwDeps != null)
{
foreach (var dep in fwDeps.Properties())
{
dependencies.Add(dep);
}
}
}
}
foreach (var dep in dependencies)
{
if (projects.Contains(dep.Name))
{
if (dep.Value.Type == JTokenType.String)
{
var newVal = new JObject();
newVal.Add("target", "project");
dep.Value = newVal;
}
else
{
var jObj = dep.Value as JObject;
var targetProp = jObj.Properties().SingleOrDefault(p => p.Name == "target");
if (targetProp == null)
{
dep.Value["target"] = "project";
}
var versionProp = jObj.Properties().SingleOrDefault(p => p.Name == "version");
if (versionProp != null)
{
versionProp.Remove();
}
}
}
}
File.WriteAllText(file.FullName, json.ToString(), Encoding.UTF8);
}
