public async Task <IVsPathContext> CreatePathContextAsync(NuGetProject nuGetProject, CancellationToken token)
{
IVsPathContext context;
try
{
context = await GetPathContextFromAssetsFileAsync(
nuGetProject, token);
context = context ?? await GetPathContextFromPackagesConfigAsync(
nuGetProject, token);
// Fallback to reading the path context from the solution's settings. Note that project level settings in
// VS are not currently supported.
context = context ?? GetSolutionPathContext();
}
catch (Exception e) when(e is KeyNotFoundException || e is InvalidOperationException)
{
var projectUniqueName = NuGetProject.GetUniqueNameOrName(nuGetProject);
var errorMessage = string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_CreateContextError, projectUniqueName, e.Message);
_logger.Value.LogError(errorMessage);
throw new InvalidOperationException(errorMessage, e);
}
return(context);
}
public static async Task <AlternativePackageManagerProviders> CalculateAlternativePackageManagersAsync(
IEnumerable <IVsPackageManagerProvider> packageManagerProviders,
string packageId,
NuGetProject project)
{
var otherProviders = new List <IVsPackageManagerProvider>();
var projectName = NuGetProject.GetUniqueNameOrName(project);
foreach (var provider in packageManagerProviders)
{
bool applicable = await provider.CheckForPackageAsync(
packageId,
projectName,
CancellationToken.None);
if (applicable)
{
otherProviders.Add(provider);
}
}
if (otherProviders.Count == 0)
{
return(null);
}
else
{
return(new AlternativePackageManagerProviders(
otherProviders,
packageId,
projectName));
}
}
private async Task <Dictionary <PackageReference, List <string> > > GetPackagesReferencesDictionaryAsync(CancellationToken token)
{
var packageReferencesDict = new Dictionary <PackageReference, List <string> >(new PackageReferenceComparer());
if (!await SolutionManager.IsSolutionAvailableAsync())
{
return(packageReferencesDict);
}
foreach (var nuGetProject in (await SolutionManager.GetNuGetProjectsAsync()))
{
// skip project k projects and build aware projects
if (nuGetProject is INuGetIntegratedProject)
{
continue;
}
var nuGetProjectName = NuGetProject.GetUniqueNameOrName(nuGetProject);
var installedPackageReferences = await nuGetProject.GetInstalledPackagesAsync(token);
foreach (var installedPackageReference in installedPackageReferences)
{
List <string> projectNames = null;
if (!packageReferencesDict.TryGetValue(installedPackageReference, out projectNames))
{
projectNames = new List <string>();
packageReferencesDict.Add(installedPackageReference, projectNames);
}
projectNames.Add(nuGetProjectName);
}
}
return(packageReferencesDict);
}
/// <summary>
/// Return all possibly valid project names in the current solution. This includes all
/// unique names and safe names.
/// </summary>
/// <returns></returns>
private IEnumerable <string> GetAllValidProjectNames()
{
var nugetProjects = VsSolutionManager.GetNuGetProjects();
var safeNames = nugetProjects?.Select(p => VsSolutionManager.GetNuGetProjectSafeName(p));
var uniqueNames = nugetProjects?.Select(p => NuGetProject.GetUniqueNameOrName(p));
return(uniqueNames.Concat(safeNames).Distinct());
}
private void WarnForReinstallOfBuildIntegratedProjects(IEnumerable <BuildIntegratedNuGetProject> projects)
{
if (projects.Any())
{
var projectNames = string.Join(",", projects.Select(p => NuGetProject.GetUniqueNameOrName(p)));
var warning = string.Format(CultureInfo.CurrentCulture, Resources.Warning_ReinstallNotRespectedForProjectType, projectNames);
Log(MessageLevel.Warning, warning);
}
}
public async Task <string> GetNuGetProjectSafeNameAsync(NuGetProject nuGetProject)
{
string name = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
if (await GetNuGetProjectAsync(name) == nuGetProject)
{
return(name);
}
return(NuGetProject.GetUniqueNameOrName(nuGetProject));
}
/// <summary>
/// Return all possibly valid project names in the current solution. This includes all
/// unique names and safe names.
/// </summary>
/// <returns></returns>
private async Task <IEnumerable <string> > GetAllValidProjectNamesAsync()
{
var nugetProjects = await VsSolutionManager.GetNuGetProjectsAsync();
var safeNames = await Task.WhenAll(nugetProjects?.Select(p => VsSolutionManager.GetNuGetProjectSafeNameAsync(p)));
var uniqueNames = nugetProjects?.Select(p => NuGetProject.GetUniqueNameOrName(p));
return(uniqueNames.Concat(safeNames).Distinct());
}
private static void EnsurePackageCompatibility(
NuGetProject nuGetProject,
PackageIdentity packageIdentity,
NuspecReader nuspecReader)
{
// Validate that the current version of NuGet satisfies the minVersion attribute specified in the .nuspec
MinClientVersionUtility.VerifyMinClientVersion(nuspecReader);
// Validate the package type. There must be zero package types or exactly one package
// type that is one of the recognized package types.
var packageTypes = nuspecReader.GetPackageTypes();
var identityString = $"{packageIdentity.Id} {packageIdentity.Version.ToNormalizedString()}";
if (packageTypes.Count > 1)
{
throw new PackagingException(string.Format(
CultureInfo.CurrentCulture,
Strings.MultiplePackageTypesNotSupported,
identityString));
}
else if (packageTypes.Count == 1)
{
var packageType = packageTypes[0];
var packageTypeString = packageType.Name;
if (packageType.Version != PackageType.EmptyVersion)
{
packageTypeString += " " + packageType.Version;
}
var projectName = NuGetProject.GetUniqueNameOrName(nuGetProject);
if (packageType == PackageType.Legacy || // Added for "quirks mode", but not yet fully implemented.
packageType == PackageType.Dependency) // A package explicitly stated as a dependency.
{
// These types are always acceptable.
}
else if (nuGetProject is ProjectKNuGetProjectBase &&
packageType == PackageType.DotnetCliTool)
{
// ProjectKNuGetProjectBase projects are .NET Core (both "dotnet" and "dnx").
// .NET CLI tools are support for "dotnet" projects. The projects eventually
// call into INuGetPackageManager, which is not implemented by NuGet. This code
// will make the decision of how to install the .NET CLI tool package.
}
else
{
throw new PackagingException(string.Format(
CultureInfo.CurrentCulture,
Strings.UnsupportedPackageType,
identityString,
packageTypeString,
projectName));
}
}
}
public static DeprecatedFrameworkModel GetDeprecatedFrameworkModel(IEnumerable <NuGetProject> affectedProjects)
{
List <string> projects = affectedProjects
.Select(project => NuGetProject.GetUniqueNameOrName(project))
.OrderBy(name => name)
.ToList();
return(new DeprecatedFrameworkModel(
FrameworkConstants.CommonFrameworks.DotNet,
DotnetDeprecationUrl,
projects));
}
protected virtual void WarnIfParametersAreNotSupported()
{
if (Source != null && Project is BuildIntegratedNuGetProject)
{
var warning = string.Format(
CultureInfo.CurrentUICulture,
"The '{0}' parameter is not respected for the transitive package management based project(s) {1}. The enabled sources in your NuGet configuration will be used.",
nameof(Source),
NuGetProject.GetUniqueNameOrName(Project));
Log(MessageLevel.Warning, warning);
}
}
private static void EnsurePackageCompatibility(
NuGetProject nuGetProject,
PackageIdentity packageIdentity,
NuspecReader nuspecReader)
{
// Validate that the current version of NuGet satisfies the minVersion attribute specified in the .nuspec
MinClientVersionUtility.VerifyMinClientVersion(nuspecReader);
// Validate the package type. There must be zero package types or exactly one package
// type that is one of the recognized package types.
var packageTypes = nuspecReader.GetPackageTypes();
var identityString = $"{packageIdentity.Id} {packageIdentity.Version.ToNormalizedString()}";
if (packageTypes.Count > 1)
{
throw new PackagingException(string.Format(
CultureInfo.CurrentCulture,
Strings.MultiplePackageTypesNotSupported,
identityString));
}
else if (packageTypes.Count == 1)
{
var packageType = packageTypes[0];
var packageTypeString = packageType.Name;
if (packageType.Version != PackageType.EmptyVersion)
{
packageTypeString += " " + packageType.Version;
}
var projectName = NuGetProject.GetUniqueNameOrName(nuGetProject);
if (packageType == PackageType.Legacy || // Added for "quirks mode", but not yet fully implemented.
packageType == PackageType.Dependency) // A package explicitly stated as a dependency.
{
// These types are always acceptable.
}
else
{
throw new PackagingException(string.Format(
CultureInfo.CurrentCulture,
Strings.UnsupportedPackageType,
identityString,
packageTypeString,
projectName));
}
}
}
public DeprecatedFrameworkModel(NuGetFramework deprecated, string migrationUrl, IEnumerable <NuGetProject> projects)
{
TextBeforeLink = string.Format(
CultureInfo.CurrentCulture,
Resources.Text_DeprecatedFramework_DocumentLink_Before,
deprecated.DotNetFrameworkName,
deprecated.GetShortFolderName());
LinkText = Resources.Text_DeprecatedFramework_DocumentLink;
TextAfterLink = Resources.Text_DeprecatedFramework_DocumentLink_After;
ProjectListText = Resources.Text_DeprecatedFramework_ProjectList;
MigrationUrl = migrationUrl;
Projects = projects
.Select(project => NuGetProject.GetUniqueNameOrName(project))
.OrderBy(name => name)
.ToList();
}
/// <summary>
/// Restore missing packages for a project in the solution
/// </summary>
/// <param name="nuGetProject"></param>
/// <returns></returns>
public virtual async Task <PackageRestoreResult> RestoreMissingPackagesAsync(string solutionDirectory,
NuGetProject nuGetProject,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
if (nuGetProject == null)
{
throw new ArgumentNullException(nameof(nuGetProject));
}
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(token);
var nuGetProjectName = NuGetProject.GetUniqueNameOrName(nuGetProject);
var projectNames = new[] { nuGetProjectName };
// When this method is called, the step to compute if a package is missing is implicit. Assume it is true
var packages = installedPackages.Select(i => new PackageRestoreData(i, projectNames, isMissing: true));
return(await RestoreMissingPackagesAsync(solutionDirectory, packages, nuGetProjectContext, token));
}
// Return short name if it's non-ambiguous.
// Return CustomUniqueName for projects that have ambigous names (such as same project name under different solution folder)
// Example: return Folder1/ProjectA if there are both ProjectA under Folder1 and Folder2
public async Task <string> GetNuGetProjectSafeNameAsync(NuGetProject nuGetProject)
{
if (nuGetProject == null)
{
throw new ArgumentNullException("nuGetProject");
}
await EnsureInitializeAsync();
// Try searching for simple names first
var name = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
if ((await GetNuGetProjectAsync(name)) == nuGetProject)
{
return(name);
}
return(NuGetProject.GetUniqueNameOrName(nuGetProject));
}
private async Task BuildIntegratedProjectRestoreAsync(
BuildIntegratedNuGetProject project,
string solutionDirectory,
List <SourceRepository> enabledSources,
ExternalProjectReferenceContext context,
RestoreCommandProvidersCache providerCache,
CancellationToken token)
{
// Go off the UI thread to perform I/O operations
await TaskScheduler.Default;
var projectName = NuGetProject.GetUniqueNameOrName(project);
var nugetPathContext = NuGetPathContext.Create(Settings);
using (var cacheContext = new SourceCacheContext())
{
providerCache.GetOrCreate(
nugetPathContext.UserPackageFolder,
nugetPathContext.FallbackPackageFolders,
enabledSources,
cacheContext,
context.Logger);
// Pass down the CancellationToken from the dialog
var restoreResult = await BuildIntegratedRestoreUtility.RestoreAsync(project,
context,
enabledSources,
nugetPathContext.UserPackageFolder,
nugetPathContext.FallbackPackageFolders,
token);
if (!restoreResult.Success)
{
// Mark this as having errors
_hasErrors = true;
// Invalidate cached results for the project. This will cause it to restore the next time.
_buildIntegratedCache.Remove(projectName);
await BuildIntegratedProjectReportErrorAsync(projectName, restoreResult, token);
}
}
}
// Return short name if it's non-ambiguous.
// Return CustomUniqueName for projects that have ambigous names (such as same project name under different solution folder)
// Example: return Folder1/ProjectA if there are both ProjectA under Folder1 and Folder2
public string GetNuGetProjectSafeName(NuGetProject nuGetProject)
{
if (nuGetProject == null)
{
throw new ArgumentNullException("nuGetProject");
}
Init();
// Try searching for simple names first
string name = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
if (GetNuGetProject(name) == nuGetProject)
{
return(name);
}
return(NuGetProject.GetUniqueNameOrName(nuGetProject));
}
internal async Task <IVsPathContext> CreatePathContextAsync(NuGetProject nuGetProject, CancellationToken token)
{
IVsPathContext context;
try
{
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
if (buildIntegratedProject != null)
{
// if project is build integrated, then read it from assets file.
context = await GetPathContextFromAssetsFileAsync(
buildIntegratedProject, token);
}
else
{
var msbuildNuGetProject = nuGetProject as MSBuildNuGetProject;
if (msbuildNuGetProject != null)
{
// when a msbuild project, then read it from packages.config file.
context = await GetPathContextFromPackagesConfigAsync(
msbuildNuGetProject, token);
}
else
{
// Fallback to reading the path context from the solution's settings. Note that project level settings in
// VS are not currently supported.
context = GetSolutionPathContext();
}
}
}
catch (Exception e) when(e is KeyNotFoundException || e is InvalidOperationException)
{
var projectUniqueName = NuGetProject.GetUniqueNameOrName(nuGetProject);
var errorMessage = string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_CreateContextError, projectUniqueName, e.Message);
_logger.Value.LogError(errorMessage);
throw new InvalidOperationException(errorMessage, e);
}
return(context);
}
private void SolutionManager_ActionsExecuted(object sender, ActionsExecutedEventArgs e)
{
if (Model.IsSolution)
{
Refresh();
}
else
{
// this is a project package manager, so there is one and only one project.
var project = Model.Context.Projects.First();
var projectName = NuGetProject.GetUniqueNameOrName(project);
// we need refresh when packages are installed into or uninstalled from the project
if (e.Actions.Any(action =>
NuGetProject.GetUniqueNameOrName(action.Project) == projectName))
{
Refresh();
}
}
}
private static string GenerateUpgradeReport(NuGetProject nuGetProject, string backupPath, NuGetProjectUpgradeWindowModel upgradeInformationWindowModel)
{
var projectName = NuGetProject.GetUniqueNameOrName(nuGetProject);
using (var upgradeLogger = new UpgradeLogger(projectName, backupPath))
{
var installedAsTopLevel = upgradeInformationWindowModel.UpgradeDependencyItems.Where(t => t.InstallAsTopLevel);
var transitiveDependencies = upgradeInformationWindowModel.TransitiveDependencies.Where(t => !t.InstallAsTopLevel);
foreach (var package in installedAsTopLevel)
{
upgradeLogger.RegisterPackage(projectName, package.Id, package.Version, package.Issues, true);
}
foreach (var package in transitiveDependencies)
{
upgradeLogger.RegisterPackage(projectName, package.Id, package.Version, package.Issues, false);
}
return(upgradeLogger.GetHtmlFilePath());
}
}
private static string CreateBackup(MSBuildNuGetProject msBuildNuGetProject, string solutionDirectory)
{
var guid = Guid.NewGuid().ToString().Split('-').First();
var backupPath = Path.Combine(solutionDirectory, $"Backup_{guid}", NuGetProject.GetUniqueNameOrName(msBuildNuGetProject));
Directory.CreateDirectory(backupPath);
// Backup packages.config
var packagesConfigFullPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath;
var packagesConfigFileName = Path.GetFileName(packagesConfigFullPath);
File.Copy(packagesConfigFullPath, Path.Combine(backupPath, packagesConfigFileName), overwrite: true);
// Backup project file
var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem;
var projectFullPath = msBuildNuGetProjectSystem.ProjectFileFullPath;
var projectFileName = Path.GetFileName(projectFullPath);
File.Copy(projectFullPath, Path.Combine(backupPath, projectFileName), overwrite: true);
return(backupPath);
}
public static async Task <PackageRestoreResult> RestoreMissingPackagesAsync(
this IPackageRestoreManager restoreManager,
string solutionDirectory,
NuGetProject nuGetProject,
INuGetProjectContext nuGetProjectContext,
PackageDownloadContext downloadContext,
CancellationToken token)
{
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(token);
var nuGetProjectName = NuGetProject.GetUniqueNameOrName(nuGetProject);
var projectNames = new[] { nuGetProjectName };
var packages = installedPackages.Select(package => new PackageRestoreData(package, projectNames, isMissing: true));
return(await restoreManager.RestoreMissingPackagesAsync(
solutionDirectory,
packages,
nuGetProjectContext,
downloadContext,
token));
}
/// <summary>
/// Restore projects with project.json and create the lock files.
/// </summary>
/// <param name="buildEnabledProjects">Projects containing project.json</param>
/// <param name="forceRestore">Force the restore to write out the lock files.
/// This is used for rebuilds.</param>
/// <returns></returns>
private async Task RestoreBuildIntegratedProjectsAsync(
string solutionDirectory,
List <BuildIntegratedProjectSystem> buildEnabledProjects,
bool forceRestore,
bool isSolutionAvailable)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (buildEnabledProjects.Any() && IsConsentGranted(Settings))
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(Settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
var message = string.Format(
CultureInfo.CurrentCulture,
NuGet.PackageManagement.VisualStudio.Strings.RelativeGlobalPackagesFolder,
globalPackagesFolder);
WriteLine(VerbosityLevel.Quiet, message);
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
var enabledSources = SourceRepositoryProvider.GetRepositories().ToList();
// Cache p2ps discovered from DTE
var referenceContext = new ExternalProjectReferenceContext(logger: this);
// No-op all project closures are up to date and all packages exist on disk.
if (await IsRestoreRequired(buildEnabledProjects, forceRestore, referenceContext))
{
var waitDialogFactory
= ServiceLocator.GetGlobalService <SVsThreadedWaitDialogFactory,
IVsThreadedWaitDialogFactory>();
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
using (var threadedWaitDialogSession = waitDialogFactory.StartWaitDialog(
waitCaption: Resources.DialogTitle,
initialProgress: new ThreadedWaitDialogProgressData(Resources.RestoringPackages,
string.Empty,
string.Empty,
isCancelable: true,
currentStep: 0,
totalSteps: 0)))
{
// Display the restore opt out message if it has not been shown yet
DisplayOptOutMessage();
Token = threadedWaitDialogSession.UserCancellationToken;
ThreadedWaitDialogProgress = threadedWaitDialogSession.Progress;
// Cache resources between requests
var providerCache = new RestoreCommandProvidersCache();
var tasks = new List <Task <KeyValuePair <string, Exception> > >();
var maxTasks = 4;
// Restore packages and create the lock file for each project
foreach (var project in buildEnabledProjects)
{
// Mark this as having missing packages so that we will not
// display a noop message in the summary
_hasMissingPackages = true;
_displayRestoreSummary = true;
if (tasks.Count >= maxTasks)
{
await ProcessTask(tasks);
}
// Skip further restores if the user has clicked cancel
if (!Token.IsCancellationRequested)
{
var projectName = NuGetProject.GetUniqueNameOrName(project);
// Restore and create a project.lock.json file
tasks.Add(RestoreProject(projectName, async() =>
await BuildIntegratedProjectRestoreAsync(
project,
solutionDirectory,
enabledSources,
referenceContext,
providerCache,
Token)));
}
}
// Wait for the remaining tasks
while (tasks.Count > 0)
{
await ProcessTask(tasks);
}
if (Token.IsCancellationRequested)
{
_canceled = true;
}
}
}
}
}
protected override void WarnIfParametersAreNotSupported()
{
if (Source != null)
{
var projectNames = string.Join(",", Projects.Where(e => e is BuildIntegratedNuGetProject).Select(p => NuGetProject.GetUniqueNameOrName(p)));
if (!string.IsNullOrEmpty(projectNames))
{
var warning = string.Format(CultureInfo.CurrentUICulture, Resources.Warning_SourceNotRespectedForProjectType, nameof(Source), projectNames);
Log(MessageLevel.Warning, warning);
}
}
}
public async Task UpgradeNuGetProjectAsync(INuGetUI uiService, NuGetProject nuGetProject)
{
var context = uiService.UIContext;
// Restore the project before proceeding
var solutionDirectory = context.SolutionManager.SolutionDirectory;
await context.PackageRestoreManager.RestoreMissingPackagesInSolutionAsync(
solutionDirectory,
uiService.ProjectContext,
new LoggerAdapter(uiService.ProjectContext),
CancellationToken.None);
var packagesDependencyInfo = await context.PackageManager.GetInstalledPackagesDependencyInfo(nuGetProject, CancellationToken.None, includeUnresolved : true);
var upgradeInformationWindowModel = new NuGetProjectUpgradeWindowModel((MSBuildNuGetProject)nuGetProject, packagesDependencyInfo.ToList());
var result = uiService.ShowNuGetUpgradeWindow(upgradeInformationWindowModel);
if (!result)
{
// raise upgrade telemetry event with Cancelled status
var packagesCount = upgradeInformationWindowModel.UpgradeDependencyItems.Count;
var upgradeTelemetryEvent = VSTelemetryServiceUtility.GetUpgradeTelemetryEvent(
uiService.Projects,
NuGetOperationStatus.Cancelled,
packagesCount);
TelemetryActivity.EmitTelemetryEvent(upgradeTelemetryEvent);
return;
}
var progressDialogData = new ProgressDialogData(Resources.NuGetUpgrade_WaitMessage);
string backupPath;
var windowTitle = string.Format(
CultureInfo.CurrentCulture,
Resources.WindowTitle_NuGetMigrator,
NuGetProject.GetUniqueNameOrName(nuGetProject));
using (var progressDialogSession = await context.StartModalProgressDialogAsync(windowTitle, progressDialogData, uiService))
{
backupPath = await PackagesConfigToPackageReferenceMigrator.DoUpgradeAsync(
context,
uiService,
nuGetProject,
upgradeInformationWindowModel.UpgradeDependencyItems,
upgradeInformationWindowModel.NotFoundPackages,
progressDialogSession.Progress,
progressDialogSession.UserCancellationToken);
}
if (!string.IsNullOrEmpty(backupPath))
{
var htmlLogFile = GenerateUpgradeReport(nuGetProject, backupPath, upgradeInformationWindowModel);
Process process = null;
try
{
process = Process.Start(htmlLogFile);
}
catch { }
}
}
protected virtual void WarnIfParametersAreNotSupported()
{
if (Source != null && Project is BuildIntegratedNuGetProject)
{
var warning = string.Format(CultureInfo.CurrentUICulture, Resources.Warning_SourceNotRespectedForProjectType, nameof(Source), NuGetProject.GetUniqueNameOrName(Project));
Log(MessageLevel.Warning, warning);
}
}
