public BuildIntegratedProjectAction(NuGetProject project,
PackageIdentity packageIdentity,
NuGetProjectActionType nuGetProjectActionType,
LockFile originalLockFile,
RestoreResultPair restoreResultPair,
IReadOnlyList<SourceRepository> sources,
IReadOnlyList<NuGetProjectAction> originalActions,
BuildIntegratedInstallationContext installationContext)
: this(project, packageIdentity, nuGetProjectActionType, originalLockFile, restoreResultPair, sources, originalActions, installationContext, versionRange: null)
{
}
public BuildIntegratedProjectAction(NuGetProject project,
PackageIdentity packageIdentity,
NuGetProjectActionType nuGetProjectActionType,
LockFile originalLockFile,
RestoreResultPair restoreResultPair,
IReadOnlyList<SourceRepository> sources,
IReadOnlyList<NuGetProjectAction> originalActions,
BuildIntegratedInstallationContext installationContext,
VersionRange versionRange)
: base(packageIdentity, nuGetProjectActionType, project, sourceRepository: null, versionRange)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (originalLockFile == null)
{
throw new ArgumentNullException(nameof(originalLockFile));
}
if (restoreResultPair == null)
{
throw new ArgumentNullException(nameof(restoreResultPair));
}
if (sources == null)
{
throw new ArgumentNullException(nameof(sources));
}
if (originalActions == null)
{
throw new ArgumentNullException(nameof(sources));
}
if (installationContext == null)
{
throw new ArgumentNullException(nameof(sources));
}
OriginalLockFile = originalLockFile;
RestoreResult = restoreResultPair.Result;
RestoreResultPair = restoreResultPair;
Sources = sources;
OriginalActions = originalActions;
InstallationContext = installationContext;
}
private static void UpdatePackageVersionIfNeeded(RestoreResultPair restorePreviewResult,
PackageReferenceArgs packageReferenceArgs)
{
// If the user did not specify a version then write the exact resolved version
if (packageReferenceArgs.NoVersion)
{
// Get the package version from the graph
var resolvedVersion = GetPackageVersionFromRestoreResult(restorePreviewResult, packageReferenceArgs);
if (resolvedVersion != null)
{
//Update the packagedependency with the new version
packageReferenceArgs.PackageDependency = new PackageDependency(packageReferenceArgs.PackageDependency.Id,
new VersionRange(resolvedVersion));
}
}
}
private static NuGetVersion GetPackageVersionFromRestoreResult(RestoreResultPair restorePreviewResult,
PackageReferenceArgs packageReferenceArgs,
IEnumerable <NuGetFramework> UserSpecifiedFrameworks)
{
// Get the restore graphs from the restore result
var restoreGraphs = restorePreviewResult
.Result
.RestoreGraphs;
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If the user specified frameworks then we get the flattened graphs only from the compatible frameworks.
var userSpecifiedFrameworkSet = new HashSet <NuGetFramework>(
UserSpecifiedFrameworks,
new NuGetFrameworkFullComparer());
restoreGraphs = restoreGraphs
.Where(r => userSpecifiedFrameworkSet.Contains(r.Framework));
}
foreach (var restoreGraph in restoreGraphs)
{
var matchingPackageEntries = restoreGraph
.Flattened
.Select(p => p)
.Where(p => p.Key.Name.Equals(packageReferenceArgs.PackageDependency.Id, StringComparison.OrdinalIgnoreCase));
if (matchingPackageEntries.Any())
{
return(matchingPackageEntries
.First()
.Key
.Version);
}
}
return(null);
}
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)
});
}
private RestoreTargetGraph GetRestoreTargetGraph(List <PackageReference> packages, string projectPath, List <NuGetFramework> targetFrameworks, SourceCacheContext sourceCacheContext)
{
// The package spec details what packages to restore
PackageSpec packageSpec = new PackageSpec(targetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i
}).ToList())
{
//Dependencies = new List<LibraryDependency>
//{
// new LibraryDependency
// {
// LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package),
// SuppressParent = LibraryIncludeFlags.All,
// AutoReferenced = true,
// IncludeType = LibraryIncludeFlags.None,
// Type = LibraryDependencyType.Build
// }
//},
Dependencies = packages.Select(i => new LibraryDependency
{
LibraryRange = new LibraryRange(i.PackageId, new VersionRange(i.PackageVersion), LibraryDependencyTarget.Package),
//SuppressParent = LibraryIncludeFlags.All,
//AutoReferenced = true,
//IncludeType = LibraryIncludeFlags.None,
//Type = LibraryDependencyType.
}).ToList(),
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = targetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(_nugetSettings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
Sources = SettingsUtility.GetEnabledSources(_nugetSettings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(_nugetSettings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(projectPath),
};
DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
RestoreArgs restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(_nugetSettings)),
Log = NullLogger.Instance,
};
// Create requests from the arguments
IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
RestoreResultPair restoreResult = RestoreRunner.RunWithoutCommit(requests, restoreArgs).Result.FirstOrDefault();
RestoreTargetGraph restoreTargetGraph = restoreResult?.Result.RestoreGraphs.FirstOrDefault();
return(restoreTargetGraph);
}
