/// <summary>
/// Attempts to find a NuGet package if it is already installed.
/// </summary>
private static bool TryGetMSBuildSdkPackageInfo(FallbackPackagePathResolver fallbackPackagePathResolver, string id, NuGetVersion version, out string installedPath, out string installedVersion)
{
// Find the package
var packageInfo = fallbackPackagePathResolver.GetPackageInfo(id, version);
if (packageInfo == null)
{
installedPath = null;
installedVersion = null;
return(false);
}
// Get the installed path and add the expected "Sdk" folder. Windows file systems are not case sensitive
installedPath = Path.Combine(packageInfo.PathResolver.GetInstallPath(packageInfo.Id, packageInfo.Version), "Sdk");
if (!NuGet.Common.RuntimeEnvironmentHelper.IsWindows && !Directory.Exists(installedPath))
{
// Fall back to lower case "sdk" folder in case the file system is case sensitive
installedPath = Path.Combine(packageInfo.PathResolver.GetInstallPath(packageInfo.Id, packageInfo.Version), "sdk");
}
installedVersion = packageInfo.Version.ToString();
return(true);
}
public static void UpdatePackageReferenceMetadata(
PackageSpec packageSpec,
FallbackPackagePathResolver pathResolver,
PackageIdentity package)
{
var info = pathResolver.GetPackageInfo(package.Id, package.Version);
var nuspecFilePath = info?.PathResolver.GetManifestFilePath(package.Id, package.Version);
var nuspecReader = new NuspecReader(nuspecFilePath);
var developmentDependency = nuspecReader.GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in packageSpec.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(dep => dep.Name.Equals(package.Id, StringComparison.OrdinalIgnoreCase));
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Runtime;
}
}
}
}
public string GetPackageDirectory(string packageId, NuGetVersion version, out string packageRoot)
{
packageRoot = null;
var pkginfo = _packagePathResolver.GetPackageInfo(packageId, version);
if (pkginfo != null)
{
packageRoot = pkginfo.PathResolver.GetVersionListPath(""); //TODO Remove Once Nuget is updated to use FallbackPackagePathInfo.PathResolver.RootPath
}
return(_packagePathResolver.GetPackageDirectory(packageId, version));
}
public string GetPackageDirectory(string packageId, NuGetVersion version, out string packageRoot)
{
var packageInfo = _packagePathResolver?.GetPackageInfo(packageId, version);
if (packageInfo == null)
{
packageRoot = null;
return(null);
}
packageRoot = packageInfo.PathResolver.RootPath;
return(packageInfo.PathResolver.GetInstallPath(packageId, version));
}
public static void UpdatePackageReferenceMetadata(
LockFile lockFile,
FallbackPackagePathResolver pathResolver,
PackageIdentity package)
{
var info = pathResolver.GetPackageInfo(package.Id, package.Version);
if (info == null)
{
// don't do anything if package was not resolved on disk
return;
}
var nuspecFilePath = info.PathResolver.GetManifestFilePath(package.Id, package.Version);
var nuspecReader = new NuspecReader(nuspecFilePath);
var developmentDependency = nuspecReader.GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in lockFile.PackageSpec.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(dep => dep.Name.Equals(package.Id, StringComparison.OrdinalIgnoreCase));
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
var includeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Compile;
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = includeType;
// update lock file target libraries
foreach (var target in lockFile.Targets
.Where(t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, frameworkInfo.FrameworkName)))
{
var targetLibrary = target.GetTargetLibrary(package.Id);
if (targetLibrary != null)
{
LockFileUtils.ExcludeItems(targetLibrary, includeType);
}
}
}
}
}
}
/// <summary>
/// Attempts to find a NuGet package if it is already installed.
/// </summary>
private static bool TryGetMSBuildSdkPackageInfo(FallbackPackagePathResolver fallbackPackagePathResolver, string id, NuGetVersion version, out string installedPath, out string installedVersion)
{
// Find the package
FallbackPackagePathInfo packageInfo = fallbackPackagePathResolver.GetPackageInfo(id, version);
if (packageInfo == null)
{
installedPath = null;
installedVersion = null;
return(false);
}
// Get the installed path and add the expected "Sdk" folder
installedPath = Path.Combine(packageInfo.PathResolver.GetInstallPath(packageInfo.Id, packageInfo.Version), "Sdk");
installedVersion = packageInfo.Version.ToString();
return(true);
}
public void EnsurePackageCompatibility(
NuGetProject nuGetProject,
INuGetPathContext pathContext,
IEnumerable <NuGetProjectAction> nuGetProjectActions,
RestoreResult restoreResult)
{
// Find all of the installed package identities.
var requestedPackageIds = new HashSet <string>(
nuGetProjectActions
.Where(action => action.NuGetProjectActionType == NuGetProjectActionType.Install)
.Select(action => action.PackageIdentity.Id),
StringComparer.OrdinalIgnoreCase);
var installedIdentities = restoreResult
.RestoreGraphs
.SelectMany(graph => graph.Flattened)
.Where(result => result.Key.Type == LibraryType.Package)
.Select(result => new PackageIdentity(result.Key.Name, result.Key.Version))
.Distinct()
.Where(identity => requestedPackageIds.Contains(identity.Id));
// Read the .nuspec on disk and ensure package compatibility.
var resolver = new FallbackPackagePathResolver(pathContext);
foreach (var identity in installedIdentities)
{
var packageInfo = resolver.GetPackageInfo(
identity.Id,
identity.Version);
if (packageInfo != null)
{
var manifestPath = packageInfo.PathResolver.GetManifestFilePath(
identity.Id,
identity.Version);
var nuspecReader = new NuspecReader(manifestPath);
EnsurePackageCompatibility(
nuGetProject,
identity,
nuspecReader);
}
}
}
private static LibraryDependency GenerateLibraryDependency(
PackageSpec project,
PackageReferenceArgs packageReferenceArgs,
RestoreResultPair restorePreviewResult,
IEnumerable <NuGetFramework> UserSpecifiedFrameworks)
{
// get the package resolved version from restore preview result
var resolvedVersion = GetPackageVersionFromRestoreResult(restorePreviewResult, packageReferenceArgs, UserSpecifiedFrameworks);
// calculate correct package version to write in project file
var version = packageReferenceArgs.PackageDependency.VersionRange;
// If the user did not specify a version then write the exact resolved version
if (packageReferenceArgs.NoVersion)
{
version = new VersionRange(resolvedVersion);
}
// update default packages path if user specified custom package directory
var packagesPath = project.RestoreMetadata.PackagesPath;
if (!string.IsNullOrEmpty(packageReferenceArgs.PackageDirectory))
{
packagesPath = packageReferenceArgs.PackageDirectory;
}
// create a path resolver to get nuspec file of the package
var pathResolver = new FallbackPackagePathResolver(
packagesPath,
project.RestoreMetadata.FallbackFolders);
var info = pathResolver.GetPackageInfo(packageReferenceArgs.PackageDependency.Id, resolvedVersion);
var packageDirectory = info?.PathResolver.GetInstallPath(packageReferenceArgs.PackageDependency.Id, resolvedVersion);
var nuspecFile = info?.PathResolver.GetManifestFileName(packageReferenceArgs.PackageDependency.Id, resolvedVersion);
var nuspecFilePath = Path.GetFullPath(Path.Combine(packageDirectory, nuspecFile));
// read development dependency from nuspec file
var developmentDependency = new NuspecReader(nuspecFilePath).GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in project.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(
dep => dep.Name.Equals(packageReferenceArgs.PackageDependency.Id, StringComparison.OrdinalIgnoreCase));
// if suppressParent and IncludeType aren't set by user, then only update those as per dev dependency
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Compile;
}
if (dependency != null)
{
dependency.LibraryRange.VersionRange = version;
return(dependency);
}
}
}
return(new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageDependency.Id,
versionRange: version,
typeConstraint: LibraryDependencyTarget.Package)
});
}
