public static async Task <ProjectTelemetryEvent> GetProjectTelemetryEventAsync(NuGetProject nuGetProject)
{
// Get the project details.
string projectUniqueName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
// Emit the project information.
try
{
string projectId = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
NuGetProjectType projectType = GetProjectType(nuGetProject);
bool isUpgradable = await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject);
return(new ProjectTelemetryEvent(
NuGetVersion.Value,
projectId,
projectType,
isUpgradable));
}
catch (Exception ex)
{
string message =
$"Failed to emit project information for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
return(null);
}
}
public static async Task <ProjectTelemetryEvent> GetProjectTelemetryEventAsync(NuGetProject nuGetProject)
{
// Get the project details.
var projectUniqueName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
// Emit the project information.
try
{
var projectId = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
// Get project type.
var projectType = NuGetProjectType.Unknown;
if (nuGetProject is MSBuildNuGetProject)
{
projectType = NuGetProjectType.PackagesConfig;
}
#if VS15
else if (nuGetProject is NetCorePackageReferenceProject)
{
projectType = NuGetProjectType.CPSBasedPackageRefs;
}
else if (nuGetProject is LegacyPackageReferenceProject)
{
projectType = NuGetProjectType.LegacyProjectSystemWithPackageRefs;
}
#endif
else if (nuGetProject is ProjectJsonNuGetProject)
{
projectType = NuGetProjectType.UwpProjectJson;
}
else if (nuGetProject is ProjectKNuGetProjectBase)
{
projectType = NuGetProjectType.XProjProjectJson;
}
// Get package count - don't attempt to get the project.json package count, because it fails on PCL project creation due to concurrency issue
var installedPackagesCount =
projectType == NuGetProjectType.UwpProjectJson ?
0 :
(await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None)).Count();
return(new ProjectTelemetryEvent(
NuGetVersion.Value,
projectId,
projectType,
installedPackagesCount));
}
catch (Exception ex)
{
var message =
$"Failed to emit project information for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
return(null);
}
}
private async Task EmitNuGetProjectAsync(NuGetProject nuGetProject)
{
// Get the project details.
var projectUniqueName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
// Emit the project information.
try
{
var projectId = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
// Get project type.
var projectType = NuGetProjectType.Unknown;
if (nuGetProject is MSBuildNuGetProject)
{
projectType = NuGetProjectType.PackagesConfig;
}
#if VS15
else if (nuGetProject is NetCorePackageReferenceProject)
{
projectType = NuGetProjectType.CPSBasedPackageRefs;
}
else if (nuGetProject is LegacyPackageReferenceProject)
{
projectType = NuGetProjectType.LegacyProjectSystemWithPackageRefs;
}
#endif
else if (nuGetProject is ProjectJsonNuGetProject)
{
projectType = NuGetProjectType.UwpProjectJson;
}
else if (nuGetProject is ProjectKNuGetProjectBase)
{
projectType = NuGetProjectType.XProjProjectJson;
}
// Get package count.
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None);
var installedPackagesCount = installedPackages.Count();
var projectInformation = new ProjectTelemetryEvent(
NuGetVersion.Value,
projectId,
projectType,
installedPackagesCount);
EmitProjectInformation(projectInformation);
}
catch (Exception ex)
{
var message =
$"Failed to emit project information for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
}
}
public static async Task <ProjectTelemetryEvent> GetProjectTelemetryEventAsync(NuGetProject nuGetProject)
{
// Get the project details.
var projectUniqueName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
// Emit the project information.
try
{
var projectId = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
// Get project type.
var projectType = NuGetProjectType.Unknown;
if (nuGetProject is MSBuildNuGetProject)
{
var msbuildProject = nuGetProject as MSBuildNuGetProject;
if (msbuildProject?.DoesPackagesConfigExists() == true)
{
projectType = NuGetProjectType.PackagesConfig;
}
else
{
projectType = NuGetProjectType.UnconfiguredNuGetType;
}
}
else if (nuGetProject is CpsPackageReferenceProject)
{
projectType = NuGetProjectType.CPSBasedPackageRefs;
}
else if (nuGetProject is LegacyPackageReferenceProject)
{
projectType = NuGetProjectType.LegacyProjectSystemWithPackageRefs;
}
else if (nuGetProject is ProjectJsonNuGetProject)
{
projectType = NuGetProjectType.UwpProjectJson;
}
var isUpgradable = await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject);
return(new ProjectTelemetryEvent(
NuGetVersion.Value,
projectId,
projectType,
isUpgradable));
}
catch (Exception ex)
{
var message =
$"Failed to emit project information for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
return(null);
}
}
public static ProjectModel ToProjectModel(this NuGetProject nuGetProject)
{
var fullPath = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.FullPath);
var nuGetFrameworkName = ((NuGetFramework)nuGetProject.GetMetadataOrNull(NuGetProjectMetadataKeys.TargetFramework))?.GetShortFolderName();
return(new ProjectModel()
{
Name = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name),
FullPath = fullPath,
FolderPath = Path.GetDirectoryName(fullPath),
FrameworkName = nuGetFrameworkName,
});
}
public PackageInstallationInfo(
NuGetProject project)
{
NuGetProject = project;
_projectName = NuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
_isSelected = false;
}
async Task ExecuteActions(
NuGetProject project,
IEnumerable <NuGetProjectAction> actions,
ConsoleHostNuGetPackageManager packageManager,
SourceCacheContext cacheContext)
{
if (actions.Any())
{
if (WhatIf.IsPresent)
{
// For -WhatIf, only preview the actions
PreviewNuGetPackageActions(actions);
}
else
{
// Execute project actions by Package Manager
await packageManager.ExecuteNuGetProjectActionsAsync(
project,
actions,
this,
cacheContext,
ConsoleHost.Token);
}
}
else
{
Log(MessageLevel.Info,
GettextCatalog.GetString("No package updates are available from the current package source for project '{0}'.",
project.GetMetadata <string> (NuGetProjectMetadataKeys.Name)));
}
}
/// <summary>
/// Execute the project actions
/// </summary>
/// <param name="actions"></param>
/// <returns></returns>
private async Task ExecuteActions(NuGetProject project, IEnumerable <NuGetProjectAction> actions)
{
if (actions.Any())
{
if (!ShouldContinueDueToDotnetDeprecation(project, actions, WhatIf.IsPresent))
{
return;
}
if (WhatIf.IsPresent)
{
// For -WhatIf, only preview the actions
PreviewNuGetPackageActions(actions);
}
else
{
// Execute project actions by Package Manager
await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, Token);
}
}
else
{
Log(MessageLevel.Info, Resources.Cmdlet_NoPackageUpdates, project.GetMetadata <string>(NuGetProjectMetadataKeys.Name));
}
}
/// <summary>
/// Get the view of PowerShellPackage. Used for Get-Package -Updates command.
/// </summary>
internal static PowerShellUpdatePackage GetPowerShellPackageUpdateView(IPackageSearchMetadata data, NuGetVersion version, VersionType versionType, NuGetProject project)
{
var package = new PowerShellUpdatePackage()
{
Id = data.Identity.Id,
Description = data.Summary,
ProjectName = project.GetMetadata <string> (NuGetProjectMetadataKeys.Name),
AsyncLazyVersions = new AsyncLazy <IEnumerable <NuGetVersion> > (async delegate {
var versions = (await data.GetVersionsAsync()) ?? Enumerable.Empty <VersionInfo> ();
var results = versions.Select(v => v.Version).OrderByDescending(v => v)
.Where(r => r > version)
.ToArray();
return(results);
}),
LicenseUrl = data.LicenseUrl?.AbsoluteUri
};
switch (versionType)
{
case VersionType.Updates:
package.AllVersions = true;
break;
case VersionType.Latest:
package.AllVersions = false;
break;
default:
Debug.Fail("Unexpected version type passed.");
break;
}
return(package);
}
public static async Task <ProjectTelemetryEvent> GetProjectTelemetryEventAsync(NuGetProject nuGetProject)
{
if (nuGetProject == null)
{
throw new ArgumentNullException(nameof(nuGetProject));
}
string projectUniqueName = string.Empty;
ProjectTelemetryEvent returnValue = null;
try
{
// Get the project details.
projectUniqueName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
string projectId = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
NuGetProjectType projectType = GetProjectType(nuGetProject);
bool isUpgradable = await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject);
string fullPath = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.FullPath);
returnValue = new ProjectTelemetryEvent(
NuGetVersion.Value,
projectId,
projectType,
isUpgradable,
fullPath);
}
catch (Exception ex)
{
// ArgumentException means project metadata is empty
// DTE exceptions could mean VS process has a severe failure
string message =
$"Failed to emit project information for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
await TelemetryUtility.PostFaultAsync(ex, nameof(VSTelemetryServiceUtility), nameof(GetProjectTelemetryEventAsync));
}
return(returnValue);
}
public PackageInstallationInfo(NuGetProject project, NuGetVersion version, bool enabled)
{
NuGetProject = project;
_name = NuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
_selected = enabled;
Version = version;
Enabled = enabled;
UpdateDisplayText();
}
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));
}
private string GetName(NuGetProject nuGetProject)
{
string nuGetProjectName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
if (!String.IsNullOrEmpty(nuGetProjectName))
{
throw new ArgumentException(String.Format(Strings.NuGetProjectDoesNotHaveName, nuGetProjectName));
}
return(nuGetProjectName);
}
/// <summary>
/// Get project's target frameworks
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
public static IEnumerable<string> GetProjectTargetFrameworks(NuGetProject project)
{
List<string> frameworks = new List<string>();
NuGetFramework nugetFramework = project.GetMetadata<NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
if (nugetFramework != null)
{
string framework = nugetFramework.ToString();
frameworks.Add(framework);
}
return frameworks;
}
/// <summary>
/// Get project's target frameworks
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
public static IEnumerable <string> GetProjectTargetFrameworks(NuGetProject project)
{
List <string> frameworks = new List <string>();
NuGetFramework nugetFramework = project.GetMetadata <NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
if (nugetFramework != null)
{
string framework = nugetFramework.ToString();
frameworks.Add(framework);
}
return(frameworks);
}
/// <summary>
/// Marks the packages to be reinstalled on the projects' packages.config
/// </summary>
public static async Task MarkPackagesForReinstallation(NuGetProject project, IList <PackageIdentity> packagesToBeReinstalled)
{
Debug.Assert(project != null);
Debug.Assert(packagesToBeReinstalled != null);
var installedPackageReferences = (await project.GetInstalledPackagesAsync(CancellationToken.None)).ToList();
var packageReferencesToUpdateReinstall = new Dictionary <Packaging.PackageReference, Packaging.PackageReference>();
if (installedPackageReferences != null && installedPackageReferences.Any())
{
foreach (var packageReference in installedPackageReferences)
{
bool markForReinstall = packagesToBeReinstalled.Any(p => p.Equals(packageReference.PackageIdentity));
// Determine if requireReinstallation attribute needs to be updated.
if (packageReference.RequireReinstallation ^ markForReinstall)
{
var newPackageReference = new Packaging.PackageReference(packageReference.PackageIdentity, packageReference.TargetFramework,
packageReference.IsUserInstalled, packageReference.IsDevelopmentDependency, markForReinstall);
packageReferencesToUpdateReinstall.Add(packageReference, newPackageReference);
}
}
var projectFullPath = project.GetMetadata <string>(NuGetProjectMetadataKeys.FullPath);
var packagesConfigFullPath = Path.Combine(projectFullPath ?? string.Empty, ProjectManagement.Constants.PackageReferenceFile);
// Create new file or overwrite existing file
if (File.Exists(packagesConfigFullPath))
{
try
{
using (var writer = new PackagesConfigWriter(packagesConfigFullPath, createNew: false))
{
foreach (var entry in packageReferencesToUpdateReinstall)
{
writer.UpdatePackageEntry(entry.Key, entry.Value);
}
}
}
catch (Exception ex)
{
ExceptionHelper.WriteErrorToActivityLog(ex);
}
}
}
}
/// <summary>
/// Get the list of packages to be reinstalled in the project. This can be run right after a project is retargeted or during every build
/// </summary>
/// <param name="project">NuGet project that the packages were installed to</param>
/// <returns>List of package identities to be reinstalled</returns>
public static async Task <IList <PackageIdentity> > GetPackagesToBeReinstalled(NuGetProject project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
var sortedPackages = new List <PackageIdentity>();
var installedRefs = await project.GetInstalledPackagesAsync(CancellationToken.None);
if (installedRefs != null && installedRefs.Any())
{
var targetFramework = project.GetMetadata <NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
return(await GetPackagesToBeReinstalledAsync(targetFramework, installedRefs));
}
return(new List <PackageIdentity>());
}
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.UniqueName);
EnvDTEProjectName envDTEProjectName;
_nuGetAndEnvDTEProjectCache.TryGetNuGetProjectName(name, out envDTEProjectName);
Debug.Assert(envDTEProjectName != null);
return(envDTEProjectName.CustomUniqueName);
}
// 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));
}
// 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));
}
/// <summary>
/// Get the view of PowerShellPackage. Used for Get-Package -Updates command.
/// </summary>
/// <param name="data"></param>
/// <param name="version"></param>
/// <param name="versionType"></param>
/// <returns></returns>
internal static PowerShellUpdatePackage GetPowerShellPackageUpdateView(PSSearchMetadata data, NuGetVersion version, VersionType versionType, NuGetProject project)
{
PowerShellUpdatePackage package = new PowerShellUpdatePackage();
package.Id = data.Identity.Id;
package.Description = data.Summary;
package.ProjectName = project.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
switch (versionType)
{
case VersionType.updates:
{
package.Versions = data.Versions.Where(p => p > version).OrderByDescending(v => v);
if (package.Versions != null && package.Versions.Any())
{
LegacyNuGet.SemanticVersion sVersion;
LegacyNuGet.SemanticVersion.TryParse(package.Versions.FirstOrDefault().ToNormalizedString(), out sVersion);
package.Version = sVersion;
}
}
break;
case VersionType.latest:
{
NuGetVersion nVersion = data.Versions.Where(p => p > version).OrderByDescending(v => v).FirstOrDefault();
if (nVersion != null)
{
package.Versions = new List <NuGetVersion>()
{
nVersion
};
LegacyNuGet.SemanticVersion sVersion;
LegacyNuGet.SemanticVersion.TryParse(nVersion.ToNormalizedString(), out sVersion);
package.Version = sVersion;
}
}
break;
}
return(package);
}
/// <summary>
/// Returns a list of package references that were marked for reinstallation in packages.config of the project
/// </summary>
public static IList <Packaging.PackageReference> GetPackageReferencesMarkedForReinstallation(NuGetProject project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
var projectFullPath = project.GetMetadata <string>(NuGetProjectMetadataKeys.FullPath);
var packagesConfigFullPath = Path.Combine(projectFullPath ?? string.Empty, NuGet.ProjectManagement.Constants.PackageReferenceFile);
if (File.Exists(packagesConfigFullPath))
{
using (var stream = File.OpenRead(packagesConfigFullPath))
{
var reader = new PackagesConfigReader(stream);
IEnumerable <Packaging.PackageReference> packageReferences = reader?.GetPackages();
return(packageReferences.Where(p => p.RequireReinstallation).ToList());
}
}
return(new List <Packaging.PackageReference>());
}
/// <summary>
/// Get default project in the type of EnvDTE.Project, to keep PowerShell scripts backward-compatbility.
/// </summary>
/// <returns></returns>
protected Project GetDefaultProject()
{
string customUniqueName = string.Empty;
Project defaultDTEProject = null;
NuGetProject defaultNuGetProject = VsSolutionManager.DefaultNuGetProject;
// Solution may be open without a project in it. Then defaultNuGetProject is null.
if (defaultNuGetProject != null)
{
customUniqueName = defaultNuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
}
// Get all DTE projects in the solution and compare by CustomUnique names, especially for projects under solution folders.
IEnumerable <Project> allDTEProjects = EnvDTESolutionUtility.GetAllEnvDTEProjects(DTE);
if (allDTEProjects != null)
{
defaultDTEProject = allDTEProjects.Where(p => StringComparer.OrdinalIgnoreCase.Equals(EnvDTEProjectUtility.GetCustomUniqueName(p), customUniqueName)).FirstOrDefault();
}
return(defaultDTEProject);
}
private async System.Threading.Tasks.Task RestorePackagesInProject(NuGetProject nuGetProject, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return;
}
var projectName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
bool hasMissingPackages = false;
try
{
hasMissingPackages = await PackageRestoreManager.RestoreMissingPackagesAsync(nuGetProject, token);
WriteLine(hasMissingPackages, error: false);
}
catch (Exception ex)
{
var exceptionMessage = _msBuildOutputVerbosity >= (int)VerbosityLevel.Detailed ?
ex.ToString() :
ex.Message;
var message = String.Format(
CultureInfo.CurrentCulture,
Resources.PackageRestoreFailedForProject, projectName,
exceptionMessage);
WriteLine(VerbosityLevel.Quiet, message);
ActivityLog.LogError(LogEntrySource, message);
ShowError(_errorListProvider, TaskErrorCategory.Error,
TaskPriority.High, message, hierarchyItem: null);
WriteLine(hasMissingPackages, error: true);
}
finally
{
WriteLine(VerbosityLevel.Normal, Resources.PackageRestoreFinishedForProject, projectName);
}
}
/// <summary>
/// Output package updates to current project(s) found from the current remote source
/// </summary>
/// <param name="packagesToDisplay"></param>
private async Task WriteUpdatePackagesFromRemoteSourceAsync(NuGetProject project)
{
var installedPackages = await project.GetInstalledPackagesAsync(Token);
installedPackages = installedPackages.Where(p => !IsAutoReferenced(p));
VersionType versionType;
if (CollapseVersions)
{
versionType = VersionType.Latest;
}
else
{
versionType = VersionType.Updates;
}
var projectHasUpdates = false;
var metadataTasks = installedPackages.Select(installedPackage =>
Task.Run(async() =>
{
var metadata = await GetLatestPackageFromRemoteSourceAsync(installedPackage.PackageIdentity, IncludePrerelease.IsPresent);
if (metadata != null)
{
await metadata.GetVersionsAsync();
}
return(metadata);
}));
foreach (var task in installedPackages.Zip(metadataTasks, (p, t) => Tuple.Create(t, p)))
{
var metadata = await task.Item1;
if (metadata != null)
{
var package = PowerShellUpdatePackage.GetPowerShellPackageUpdateView(metadata, task.Item2.PackageIdentity.Version, versionType, project);
var versions = package.Versions ?? Enumerable.Empty <NuGetVersion>();
if (versions.Any())
{
projectHasUpdates = true;
WriteObject(package);
}
}
}
if (!projectHasUpdates)
{
LogCore(MessageLevel.Info, string.Format(CultureInfo.CurrentCulture, Resources.Cmdlet_NoPackageUpdates, project.GetMetadata <string>(NuGetProjectMetadataKeys.Name)));
}
}
/// <summary>
/// Preview update actions for all packages
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
private async Task PreviewAndExecuteUpdateActionsforAllPackages(NuGetProject project)
{
var token = CancellationToken.None;
IEnumerable<NuGetProjectAction> actions = Enumerable.Empty<NuGetProjectAction>();
// Get the list of package ids or identities to be updated for PackageManager
if (Reinstall.IsPresent)
{
// Update-Package -Reinstall -> get list of installed package identities
IEnumerable<PackageIdentity> identitiesToUpdate = Enumerable.Empty<PackageIdentity>();
identitiesToUpdate = (await project.GetInstalledPackagesAsync(token)).Select(v => v.PackageIdentity);
// Preview Update-Package -Reinstall actions
actions = await PackageManager.PreviewReinstallPackagesAsync(identitiesToUpdate, project, ResolutionContext,
this, ActiveSourceRepository, null, token);
}
else
{
// Update-Package -> get list of installed package ids
IEnumerable<string> idsToUpdate = Enumerable.Empty<string>();
idsToUpdate = await GeneratePackageIdListForUpdate(project, token);
// Preview Update-Package actions
actions = await PackageManager.PreviewUpdatePackagesAsync(idsToUpdate, project, ResolutionContext,
this, ActiveSourceRepository, null, token);
}
if (actions.Any())
{
if (WhatIf.IsPresent)
{
// For -WhatIf, only preview the actions
PreviewNuGetPackageActions(actions);
}
else
{
if (Reinstall.IsPresent)
{
var uninstallActions = actions.Where(a => a.NuGetProjectActionType == NuGetProjectActionType.Uninstall);
var installActions = actions.Where(a => a.NuGetProjectActionType == NuGetProjectActionType.Install);
// Execute uninstall actions first to ensure that the package is completely uninstalled even from packages folder
await PackageManager.ExecuteNuGetProjectActionsAsync(project, uninstallActions, this, CancellationToken.None);
// Execute install actions now
await PackageManager.ExecuteNuGetProjectActionsAsync(project, installActions, this, CancellationToken.None);
}
else
{
// Execute project actions by Package Manager
await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None);
}
}
}
else
{
Log(MessageLevel.Info, string.Format(Resources.Cmdlet_NoPackageUpdates, project.GetMetadata<string>(NuGetProjectMetadataKeys.Name)));
}
}
async Task WriteUpdatePackagesFromRemoteSourceAsync(NuGetProject project)
{
var frameworks = PowerShellCmdletsUtility.GetProjectTargetFrameworks(project);
var installedPackages = await project.GetInstalledPackagesAsync(ConsoleHost.Token);
VersionType versionType;
if (collapseVersions)
{
versionType = VersionType.Latest;
}
else
{
versionType = VersionType.Updates;
}
bool projectHasUpdates = false;
var metadataTasks = installedPackages.Select(
installedPackage =>
Task.Run(async() => {
var metadata = await GetLatestPackageFromRemoteSourceAsync(project, installedPackage.PackageIdentity, IncludePrerelease.IsPresent);
if (metadata != null)
{
await metadata.GetVersionsAsync();
}
return(metadata);
}));
foreach (var task in installedPackages.Zip(metadataTasks, (p, t) => Tuple.Create(t, p)))
{
var metadata = await task.Item1;
if (metadata != null)
{
var package = PowerShellUpdatePackage.GetPowerShellPackageUpdateView(metadata, task.Item2.PackageIdentity.Version, versionType, project);
var versions = package.Versions ?? Enumerable.Empty <NuGet.Versioning.NuGetVersion> ();
if (versions.Any())
{
projectHasUpdates = true;
WriteObject(package);
}
}
}
if (!projectHasUpdates)
{
Log(MessageLevel.Info,
GettextCatalog.GetString("No package updates are available from the current package source for project '{0}'.", project.GetMetadata <string> (NuGetProjectMetadataKeys.Name)));
}
}
/// <summary>
/// Executes the list of <param name="nuGetProjectActions"></param> on <param name="nuGetProject"></param>, which is likely obtained by calling into PreviewInstallPackageAsync
/// <param name="nuGetProjectContext"></param> is used in the process
/// </summary>
public async Task ExecuteNuGetProjectActionsAsync(NuGetProject nuGetProject, IEnumerable<NuGetProjectAction> nuGetProjectActions,
INuGetProjectContext nuGetProjectContext, CancellationToken token)
{
if (nuGetProject == null)
{
throw new ArgumentNullException("nuGetProject");
}
if (nuGetProjectActions == null)
{
throw new ArgumentNullException("nuGetProjectActions");
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
Exception executeNuGetProjectActionsException = null;
Stack<NuGetProjectAction> executedNuGetProjectActions = new Stack<NuGetProjectAction>();
HashSet<PackageIdentity> packageWithDirectoriesToBeDeleted = new HashSet<PackageIdentity>(PackageIdentity.Comparer);
try
{
await nuGetProject.PreProcessAsync(nuGetProjectContext, token);
foreach (NuGetProjectAction nuGetProjectAction in nuGetProjectActions)
{
executedNuGetProjectActions.Push(nuGetProjectAction);
if (nuGetProjectAction.NuGetProjectActionType == NuGetProjectActionType.Uninstall)
{
await ExecuteUninstallAsync(nuGetProject, nuGetProjectAction.PackageIdentity, packageWithDirectoriesToBeDeleted, nuGetProjectContext, token);
}
else
{
using (var targetPackageStream = new MemoryStream())
{
await PackageDownloader.GetPackageStream(nuGetProjectAction.SourceRepository, nuGetProjectAction.PackageIdentity, targetPackageStream, token);
await ExecuteInstallAsync(nuGetProject, nuGetProjectAction.PackageIdentity, targetPackageStream, packageWithDirectoriesToBeDeleted, nuGetProjectContext, token);
}
}
string toFromString = nuGetProjectAction.NuGetProjectActionType == NuGetProjectActionType.Install ? Strings.To : Strings.From;
nuGetProjectContext.Log(MessageLevel.Info, Strings.SuccessfullyExecutedPackageAction,
nuGetProjectAction.NuGetProjectActionType.ToString().ToLowerInvariant(), nuGetProjectAction.PackageIdentity.ToString(), toFromString + " " + nuGetProject.GetMetadata<string>(NuGetProjectMetadataKeys.Name));
}
await nuGetProject.PostProcessAsync(nuGetProjectContext, token);
await OpenReadmeFile(nuGetProjectContext, token);
}
catch (Exception ex)
{
executeNuGetProjectActionsException = ex;
}
if(executeNuGetProjectActionsException != null)
{
await Rollback(nuGetProject, executedNuGetProjectActions, packageWithDirectoriesToBeDeleted, nuGetProjectContext, token);
}
// Delete the package directories as the last step, so that, if an uninstall had to be rolled back, we can just use the package file on the directory
// Also, always perform deletion of package directories, even in a rollback, so that there are no stale package directories
foreach(var packageWithDirectoryToBeDeleted in packageWithDirectoriesToBeDeleted)
{
await DeletePackage(packageWithDirectoryToBeDeleted, nuGetProjectContext, token);
}
// Clear direct install
SetDirectInstall(null, nuGetProjectContext);
if(executeNuGetProjectActionsException != null)
{
throw executeNuGetProjectActionsException;
}
}
private void WritePackages(Dictionary<PSSearchMetadata, NuGetVersion> remoteUpdates, VersionType versionType, NuGetProject project)
{
List<PowerShellUpdatePackage> view = new List<PowerShellUpdatePackage>();
foreach (KeyValuePair<PSSearchMetadata, NuGetVersion> pair in remoteUpdates)
{
PowerShellUpdatePackage package = PowerShellUpdatePackage.GetPowerShellPackageUpdateView(pair.Key, pair.Value, versionType, project);
if (package.Versions != null && package.Versions.Any())
{
view.Add(package);
}
}
if (view.Any())
{
WriteObject(view, enumerateCollection: true);
}
else
{
LogCore(MessageLevel.Info, string.Format(Resources.Cmdlet_NoPackageUpdates, project.GetMetadata<string>(NuGetProjectMetadataKeys.Name)));
}
}
public async Task<IEnumerable<NuGetProjectAction>> PreviewInstallPackageAsync(NuGetProject nuGetProject, PackageIdentity packageIdentity,
ResolutionContext resolutionContext, INuGetProjectContext nuGetProjectContext,
IEnumerable<SourceRepository> primarySources, IEnumerable<SourceRepository> secondarySources,
CancellationToken token)
{
if(nuGetProject == null)
{
throw new ArgumentNullException("nuGetProject");
}
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if(resolutionContext == null)
{
throw new ArgumentNullException("resolutionContext");
}
if(nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
if (primarySources == null)
{
throw new ArgumentNullException("primarySources");
}
if (secondarySources == null)
{
secondarySources = SourceRepositoryProvider.GetRepositories().Where(e => e.PackageSource.IsEnabled);
}
if(!primarySources.Any())
{
throw new ArgumentException("primarySources");
}
if(packageIdentity.Version == null)
{
throw new ArgumentNullException("packageIdentity.Version");
}
// TODO: BUGBUG: HACK: Multiple primary repositories is mainly intended for nuget.exe at the moment
// The following special case for ProjectK is not correct, if they used nuget.exe
// and multiple repositories in the -Source switch
if (nuGetProject is ProjectManagement.Projects.ProjectKNuGetProjectBase)
{
var action = NuGetProjectAction.CreateInstallProjectAction(packageIdentity, primarySources.First());
return new NuGetProjectAction[] { action };
}
var projectInstalledPackageReferences = await nuGetProject.GetInstalledPackagesAsync(token);
var oldListOfInstalledPackages = projectInstalledPackageReferences.Select(p => p.PackageIdentity);
if(oldListOfInstalledPackages.Any(p => p.Equals(packageIdentity)))
{
string projectName;
nuGetProject.TryGetMetadata<string>(NuGetProjectMetadataKeys.Name, out projectName);
throw new InvalidOperationException(String.Format(NuGet.ProjectManagement.Strings.PackageAlreadyExistsInProject, packageIdentity, projectName ?? String.Empty));
}
List<NuGetProjectAction> nuGetProjectActions = new List<NuGetProjectAction>();
// TODO: these sources should be ordered
// TODO: search in only the active source but allow dependencies to come from other sources?
var effectiveSources = GetEffectiveSources(primarySources, secondarySources);
if (resolutionContext.DependencyBehavior != DependencyBehavior.Ignore)
{
try
{
bool downgradeAllowed = false;
var packageTargetsForResolver = new HashSet<PackageIdentity>(oldListOfInstalledPackages, PackageIdentity.Comparer);
// Note: resolver needs all the installed packages as targets too. And, metadata should be gathered for the installed packages as well
var installedPackageWithSameId = packageTargetsForResolver.Where(p => p.Id.Equals(packageIdentity.Id, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if(installedPackageWithSameId != null)
{
packageTargetsForResolver.Remove(installedPackageWithSameId);
if(installedPackageWithSameId.Version > packageIdentity.Version)
{
// Looks like the installed package is of higher version than one being installed. So, we take it that downgrade is allowed
downgradeAllowed = true;
}
}
packageTargetsForResolver.Add(packageIdentity);
// Step-1 : Get metadata resources using gatherer
var targetFramework = nuGetProject.GetMetadata<NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
nuGetProjectContext.Log(MessageLevel.Info, Strings.AttemptingToGatherDependencyInfo, packageIdentity, targetFramework);
var primaryPackages = new List<PackageIdentity>() { packageIdentity };
// If any targets are prerelease we should gather with prerelease on and filter afterwards
bool includePrereleaseInGather = resolutionContext.IncludePrerelease || (packageTargetsForResolver.Any(p => (p.HasVersion && p.Version.IsPrerelease)));
ResolutionContext contextForGather = new ResolutionContext(resolutionContext.DependencyBehavior, includePrereleaseInGather, resolutionContext.IncludeUnlisted);
var availablePackageDependencyInfoWithSourceSet = await ResolverGather.GatherPackageDependencyInfo(contextForGather,
primaryPackages,
packageTargetsForResolver,
targetFramework,
primarySources,
effectiveSources,
token);
if (!availablePackageDependencyInfoWithSourceSet.Any())
{
throw new InvalidOperationException(String.Format(Strings.UnableToGatherDependencyInfo, packageIdentity));
}
// Prune the results down to only what we would allow to be installed
// Keep only the target package we are trying to install for that Id
IEnumerable<SourceDependencyInfo> prunedAvailablePackages = PrunePackageTree.RemoveAllVersionsForIdExcept(availablePackageDependencyInfoWithSourceSet, packageIdentity);
if (!resolutionContext.IncludePrerelease)
{
prunedAvailablePackages = PrunePackageTree.PrunePreleaseForStableTargets(prunedAvailablePackages, packageTargetsForResolver);
}
// Remove versions that do not satisfy 'allowedVersions' attribute in packages.config, if any
prunedAvailablePackages = PrunePackageTree.PruneDisallowedVersions(prunedAvailablePackages, projectInstalledPackageReferences);
// TODO: prune down level packages?
// Step-2 : Call IPackageResolver.Resolve to get new list of installed packages
// TODO: Consider using IPackageResolver once it is extensible
var packageResolver = new PackageResolver(resolutionContext.DependencyBehavior);
nuGetProjectContext.Log(MessageLevel.Info, Strings.AttemptingToResolveDependencies, packageIdentity, resolutionContext.DependencyBehavior);
// Note: resolver prefers installed package versions if the satisfy the dependency version constraints
// So, since we want an exact version of a package, create a new list of installed packages where the packageIdentity being installed
// is present after removing the one with the same id
var preferredPackageReferences = new List<PackageReference>(projectInstalledPackageReferences.Where(pr =>
!pr.PackageIdentity.Id.Equals(packageIdentity.Id, StringComparison.OrdinalIgnoreCase)));
preferredPackageReferences.Add(new PackageReference(packageIdentity, targetFramework));
IEnumerable<PackageIdentity> newListOfInstalledPackages = packageResolver.Resolve(packageTargetsForResolver,
prunedAvailablePackages,
preferredPackageReferences,
token);
if (newListOfInstalledPackages == null)
{
throw new InvalidOperationException(String.Format(Strings.UnableToResolveDependencyInfo, packageIdentity, resolutionContext.DependencyBehavior));
}
// Step-3 : Get the list of nuGetProjectActions to perform, install/uninstall on the nugetproject
// based on newPackages obtained in Step-2 and project.GetInstalledPackages
nuGetProjectContext.Log(MessageLevel.Info, Strings.ResolvingActionsToInstallPackage, packageIdentity);
var newPackagesToUninstall = new List<PackageIdentity>();
foreach(var oldInstalledPackage in oldListOfInstalledPackages)
{
var newPackageWithSameId = newListOfInstalledPackages
.Where(np => oldInstalledPackage.Id.Equals(np.Id, StringComparison.OrdinalIgnoreCase) &&
!oldInstalledPackage.Version.Equals(np.Version)).FirstOrDefault();
if(newPackageWithSameId != null)
{
if(!downgradeAllowed && oldInstalledPackage.Version > newPackageWithSameId.Version)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Strings.NewerVersionAlreadyReferenced, newPackageWithSameId.Id));
}
newPackagesToUninstall.Add(oldInstalledPackage);
}
}
var newPackagesToInstall = newListOfInstalledPackages.Where(p => !oldListOfInstalledPackages.Contains(p));
foreach (PackageIdentity newPackageToUninstall in newPackagesToUninstall)
{
nuGetProjectActions.Add(NuGetProjectAction.CreateUninstallProjectAction(newPackageToUninstall));
}
var comparer = PackageIdentity.Comparer;
foreach (PackageIdentity newPackageToInstall in newPackagesToInstall)
{
// find the package match based on identity
SourceDependencyInfo sourceDepInfo = prunedAvailablePackages.Where(p => comparer.Equals(p, newPackageToInstall)).SingleOrDefault();
if (sourceDepInfo == null)
{
// this really should never happen
throw new InvalidOperationException(String.Format(Strings.PackageNotFound, packageIdentity));
}
nuGetProjectActions.Add(NuGetProjectAction.CreateInstallProjectAction(newPackageToInstall, sourceDepInfo.Source));
}
}
catch (InvalidOperationException)
{
throw;
}
catch (AggregateException aggregateEx)
{
throw new InvalidOperationException(aggregateEx.Message, aggregateEx);
}
catch (Exception ex)
{
if (String.IsNullOrEmpty(ex.Message))
{
throw new InvalidOperationException(String.Format(Strings.PackageCouldNotBeInstalled, packageIdentity), ex);
}
else
{
throw new InvalidOperationException(ex.Message, ex);
}
}
}
else
{
var sourceRepository = await GetSourceRepository(packageIdentity, effectiveSources);
nuGetProjectActions.Add(NuGetProjectAction.CreateInstallProjectAction(packageIdentity, sourceRepository));
}
nuGetProjectContext.Log(MessageLevel.Info, Strings.ResolvedActionsToInstallPackage, packageIdentity);
return nuGetProjectActions;
}
/// <summary>
/// Gives the preview as a list of NuGetProjectActions that will be performed to uninstall <param name="packageId"></param> into <param name="nuGetProject"></param>
/// <param name="uninstallationContext"></param> and <param name="nuGetProjectContext"></param> are used in the process
/// </summary>
public async Task<IEnumerable<NuGetProjectAction>> PreviewUninstallPackageAsync(NuGetProject nuGetProject, PackageIdentity packageIdentity,
UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token)
{
if (nuGetProject == null)
{
throw new ArgumentNullException("nuGetProject");
}
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (uninstallationContext == null)
{
throw new ArgumentNullException("uninstallationContext");
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
// Step-1: Get the packageIdentity corresponding to packageId and check if it exists to be uninstalled
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(token);
PackageReference packageReference = installedPackages
.Where(pr => pr.PackageIdentity.Equals(packageIdentity)).FirstOrDefault();
if (packageReference == null || packageReference.PackageIdentity == null)
{
throw new ArgumentException(String.Format(Strings.PackageToBeUninstalledCouldNotBeFound,
packageIdentity.Id, nuGetProject.GetMetadata<string>(NuGetProjectMetadataKeys.Name)));
}
return await PreviewUninstallPackageAsyncPrivate(nuGetProject, packageReference, uninstallationContext, nuGetProjectContext, token);
}
public async Task<IEnumerable<PackageIdentity>> GetInstalledPackagesInDependencyOrder(NuGetProject nuGetProject,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
var targetFramework = nuGetProject.GetMetadata<NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(token);
var installedPackageIdentities = installedPackages.Select(pr => pr.PackageIdentity);
var dependencyInfoFromPackagesFolder = await GetDependencyInfoFromPackagesFolder(installedPackageIdentities,
targetFramework, includePrerelease: true);
var packageResolver = new PackageResolver(DependencyBehavior.Lowest);
return packageResolver.Resolve(installedPackageIdentities, dependencyInfoFromPackagesFolder, installedPackages, token);
}
private async Task EmitNuGetProjectAsync(EnvDTEProject vsProject, NuGetProject nuGetProject)
{
// Get the project details.
var projectUniqueName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName);
var projectId = Guid.Empty;
try
{
projectId = await ThreadHelper.JoinableTaskFactory.RunAsync(async delegate
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
// Get the project ID.
var vsHierarchyItem = VsHierarchyUtility.GetHierarchyItemForProject(vsProject);
Guid id;
if (!vsHierarchyItem.TryGetProjectId(out id))
{
id = Guid.Empty;
}
return(id);
});
}
catch (Exception ex)
{
var message =
$"Failed to get project name or project ID. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
return;
}
// Emit the project information.
try
{
var projectType = NuGetProjectType.Unknown;
if (nuGetProject is MSBuildNuGetProject)
{
projectType = NuGetProjectType.PackagesConfig;
}
else if (nuGetProject is BuildIntegratedNuGetProject)
{
projectType = NuGetProjectType.UwpProjectJson;
}
else if (nuGetProject is ProjectKNuGetProjectBase)
{
projectType = NuGetProjectType.XProjProjectJson;
}
var projectInformation = new ProjectInformation(
NuGetVersion.Value,
projectId,
projectType);
_nuGetTelemetryService.EmitProjectInformation(projectInformation);
}
catch (Exception ex)
{
var message =
$"Failed to emit project information for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(ExceptionHelper.LogEntrySource, message);
Debug.Fail(message);
}
// Emit the project dependency statistics.
try
{
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None);
var installedPackagesCount = installedPackages.Count();
var projectDependencyStatistics = new ProjectDependencyStatistics(
NuGetVersion.Value,
projectId,
installedPackagesCount);
_nuGetTelemetryService.EmitProjectDependencyStatistics(projectDependencyStatistics);
}
catch (Exception ex)
{
var message =
$"Failed to emit project dependency statistics for project '{projectUniqueName}'. Exception:" +
Environment.NewLine +
ex.ToString();
ActivityLog.LogWarning(message, ExceptionHelper.LogEntrySource);
Debug.Fail(message);
}
}
public string GetNuGetProjectSafeName(NuGetProject nuGetProject)
{
return(nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name));
}
public string GetNuGetProjectSafeName(NuGetProject nuGetProject)
{
return nuGetProject.GetMetadata<string>(NuGetProjectMetadataKeys.Name);
}
public Task <string> GetNuGetProjectSafeNameAsync(NuGetProject nuGetProject)
{
return(Task.FromResult(nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name)));
}
/// <summary>
/// Preview update actions for single package
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
private async Task PreviewAndExecuteUpdateActionsforSinglePackage(NuGetProject project)
{
var token = CancellationToken.None;
PackageReference installedPackage = (await project.GetInstalledPackagesAsync(token))
.Where(p => string.Equals(p.PackageIdentity.Id, Id, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// If package Id exists in Packages folder but is not actually installed to the current project, throw.
if (installedPackage == null)
{
Log(MessageLevel.Error, string.Format(Resources.PackageNotInstalledInAnyProject, Id));
}
else
{
// If -Version switch is specified
if (!string.IsNullOrEmpty(Version))
{
PackageIdentity update = GetUpdatePackageIdentityWhenVersionSpecified(project, installedPackage);
if (update != null)
{
// Update by package identity
await InstallPackageByIdentityAsync(project, update, ResolutionContext, this, WhatIf.IsPresent, Reinstall.IsPresent, UninstallContext);
}
else
{
Log(MessageLevel.Info, string.Format(Resources.Cmdlet_NoPackageUpdates, project.GetMetadata<string>(NuGetProjectMetadataKeys.Name)));
}
}
else
{
if (Reinstall.IsPresent)
{
// Update-Package Id -Reinstall
PackageIdentity identity = installedPackage.PackageIdentity;
await InstallPackageByIdentityAsync(project, identity, ResolutionContext, this, WhatIf.IsPresent, Reinstall.IsPresent, UninstallContext);
}
else
{
// Update-Package Id
NormalizePackageId(project);
NuGetVersion latestVersion = PowerShellCmdletsUtility.GetLastestVersionForPackageId(ActiveSourceRepository, Id, project, _allowPrerelease);
if (latestVersion > installedPackage.PackageIdentity.Version)
{
await InstallPackageByIdAsync(project, Id, ResolutionContext, this, WhatIf.IsPresent, Reinstall.IsPresent, UninstallContext);
}
else
{
Log(MessageLevel.Info, string.Format(Resources.Cmdlet_NoPackageUpdates, project.GetMetadata<string>(NuGetProjectMetadataKeys.Name)));
}
}
}
}
}
/// <summary>
/// Get the view of PowerShellPackage. Used for Get-Package -Updates command.
/// </summary>
/// <param name="data"></param>
/// <param name="version"></param>
/// <param name="versionType"></param>
/// <returns></returns>
internal static PowerShellUpdatePackage GetPowerShellPackageUpdateView(PSSearchMetadata data, NuGetVersion version, VersionType versionType, NuGetProject project)
{
PowerShellUpdatePackage package = new PowerShellUpdatePackage();
package.Id = data.Identity.Id;
package.Description = data.Summary;
package.ProjectName = project.GetMetadata<string>(NuGetProjectMetadataKeys.Name);
switch (versionType)
{
case VersionType.updates:
{
package.Versions = data.Versions.Where(p => p > version).OrderByDescending(v => v);
if (package.Versions != null && package.Versions.Any())
{
LegacyNuGet.SemanticVersion sVersion;
LegacyNuGet.SemanticVersion.TryParse(package.Versions.FirstOrDefault().ToNormalizedString(), out sVersion);
package.Version = sVersion;
}
}
break;
case VersionType.latest:
{
NuGetVersion nVersion = data.Versions.Where(p => p > version).OrderByDescending(v => v).FirstOrDefault();
if (nVersion != null)
{
package.Versions = new List<NuGetVersion>() { nVersion };
LegacyNuGet.SemanticVersion sVersion;
LegacyNuGet.SemanticVersion.TryParse(nVersion.ToNormalizedString(), out sVersion);
package.Version = sVersion;
}
}
break;
}
return package;
}
public async ValueTask <IReadOnlyCollection <IPackageReferenceContextInfo> > GetInstalledPackagesAsync(
IReadOnlyCollection <string> projectIds,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
cancellationToken.ThrowIfCancellationRequested();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
List <Task <IEnumerable <PackageReference> > > tasks = projects
.Select(project => project.GetInstalledPackagesAsync(cancellationToken))
.ToList();
IEnumerable <PackageReference>[] results = await Task.WhenAll(tasks);
var installedPackages = new List <PackageReferenceContextInfo>();
GetInstalledPackagesAsyncTelemetryEvent?telemetryEvent = null;
for (var i = 0; i < results.Length; ++i)
{
IEnumerable <PackageReference> packageReferences = results[i];
int totalCount = 0;
int nullCount = 0;
foreach (PackageReference?packageReference in packageReferences)
{
++totalCount;
if (packageReference is null)
{
++nullCount;
continue;
}
PackageReferenceContextInfo installedPackage = PackageReferenceContextInfo.Create(packageReference);
installedPackages.Add(installedPackage);
}
if (nullCount > 0)
{
telemetryEvent ??= new GetInstalledPackagesAsyncTelemetryEvent();
NuGetProject project = projects[i];
string projectId = project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
NuGetProjectType projectType = VSTelemetryServiceUtility.GetProjectType(project);
telemetryEvent.AddProject(projectType, projectId, nullCount, totalCount);
}
}
if (telemetryEvent is object)
{
TelemetryActivity.EmitTelemetryEvent(telemetryEvent);
}
return(installedPackages);
}
private string GetName(NuGetProject nuGetProject)
{
string nuGetProjectName = nuGetProject.GetMetadata<string>(NuGetProjectMetadataKeys.Name);
if(!String.IsNullOrEmpty(nuGetProjectName))
{
throw new ArgumentException(String.Format(Strings.NuGetProjectDoesNotHaveName, nuGetProjectName));
}
return nuGetProjectName;
}
public async Task<IEnumerable<NuGetProjectAction>> PreviewReinstallPackagesAsync(IEnumerable<PackageIdentity> packagesToInstall, NuGetProject nuGetProject,
ResolutionContext resolutionContext, INuGetProjectContext nuGetProjectContext,
SourceRepository primarySourceRepository, IEnumerable<SourceRepository> secondarySources,
CancellationToken token)
{
if(packagesToInstall == null)
{
throw new ArgumentNullException("packagesToInstall");
}
if (nuGetProject == null)
{
throw new ArgumentNullException("nuGetProject");
}
if (resolutionContext == null)
{
throw new ArgumentNullException("resolutionContext");
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
if(packagesToInstall.Any(p => p.Version == null))
{
throw new ArgumentException("packagesToInstall");
}
if (primarySourceRepository == null)
{
throw new ArgumentNullException("primarySourceRepository");
}
var primarySources = new List<SourceRepository>() { primarySourceRepository };
if (secondarySources == null)
{
secondarySources = SourceRepositoryProvider.GetRepositories().Where(e => e.PackageSource.IsEnabled);
}
var projectInstalledPackageReferences = await nuGetProject.GetInstalledPackagesAsync(token);
var oldListOfInstalledPackages = projectInstalledPackageReferences.Select(p => p.PackageIdentity);
// Note: resolver needs all the installed packages as targets too. And, metadata should be gathered for the installed packages as well
var packageTargetsForResolver = new HashSet<PackageIdentity>(oldListOfInstalledPackages, PackageIdentity.Comparer);
foreach(var packageToInstall in packagesToInstall)
{
packageTargetsForResolver.Add(packageToInstall);
}
List<NuGetProjectAction> nuGetProjectActions = new List<NuGetProjectAction>();
// TODO: these sources should be ordered
// TODO: search in only the active source but allow dependencies to come from other sources?
var effectiveSources = GetEffectiveSources(primarySources, secondarySources);
try
{
// If any targets are prerelease we should gather with prerelease on and filter afterwards
bool includePrereleaseInGather = resolutionContext.IncludePrerelease || (packageTargetsForResolver.Any(p => (p.HasVersion && p.Version.IsPrerelease)));
ResolutionContext contextForGather = new ResolutionContext(resolutionContext.DependencyBehavior, includePrereleaseInGather, resolutionContext.IncludeUnlisted);
// Step-1 : Get metadata resources using gatherer
var targetFramework = nuGetProject.GetMetadata<NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
nuGetProjectContext.Log(MessageLevel.Info, Strings.AttemptingToGatherDependencyInfoForMultiplePackages, targetFramework);
var availablePackageDependencyInfoWithSourceSet = await ResolverGather.GatherPackageDependencyInfo(contextForGather,
packagesToInstall,
packageTargetsForResolver,
targetFramework,
primarySources,
effectiveSources,
token);
if (!availablePackageDependencyInfoWithSourceSet.Any())
{
throw new InvalidOperationException(Strings.UnableToGatherDependencyInfoForMultiplePackages);
}
// Prune the results down to only what we would allow to be installed
IEnumerable<SourceDependencyInfo> prunedAvailablePackages = availablePackageDependencyInfoWithSourceSet;
// Keep only the target package we are trying to install for that Id
foreach (var packageIdentity in packagesToInstall)
{
prunedAvailablePackages = PrunePackageTree.RemoveAllVersionsForIdExcept(prunedAvailablePackages, packageIdentity);
}
if (!resolutionContext.IncludePrerelease)
{
prunedAvailablePackages = PrunePackageTree.PrunePreleaseForStableTargets(prunedAvailablePackages, packageTargetsForResolver);
}
// TODO: prune down level packages?
// Remove versions that do not satisfy 'allowedVersions' attribute in packages.config, if any
prunedAvailablePackages = PrunePackageTree.PruneDisallowedVersions(prunedAvailablePackages, projectInstalledPackageReferences);
// Step-2 : Call IPackageResolver.Resolve to get new list of installed packages
// TODO: Consider using IPackageResolver once it is extensible
var packageResolver = new PackageResolver(resolutionContext.DependencyBehavior);
nuGetProjectContext.Log(MessageLevel.Info, Strings.AttemptingToResolveDependenciesForMultiplePackages);
IEnumerable<PackageIdentity> newListOfInstalledPackages = packageResolver.Resolve(packageTargetsForResolver,
prunedAvailablePackages,
projectInstalledPackageReferences,
token);
if (newListOfInstalledPackages == null)
{
throw new InvalidOperationException(Strings.UnableToResolveDependencyInfoForMultiplePackages);
}
var packagesInDependencyOrder = (await GetInstalledPackagesInDependencyOrder(nuGetProject,
nuGetProjectContext, token)).Reverse();
foreach(var package in packagesInDependencyOrder)
{
nuGetProjectActions.Add(NuGetProjectAction.CreateUninstallProjectAction(package));
}
var comparer = PackageIdentity.Comparer;
foreach (PackageIdentity newPackageToInstall in newListOfInstalledPackages)
{
// find the package match based on identity
SourceDependencyInfo sourceDepInfo = availablePackageDependencyInfoWithSourceSet.Where(p => comparer.Equals(p, newPackageToInstall)).SingleOrDefault();
if (sourceDepInfo == null)
{
// this really should never happen
throw new InvalidOperationException(String.Format(Strings.PackageNotFound, newPackageToInstall));
}
nuGetProjectActions.Add(NuGetProjectAction.CreateInstallProjectAction(newPackageToInstall, sourceDepInfo.Source));
}
}
catch(InvalidOperationException)
{
throw;
}
catch (AggregateException aggregateEx)
{
throw new InvalidOperationException(aggregateEx.Message, aggregateEx);
}
catch (Exception ex)
{
if(String.IsNullOrEmpty(ex.Message))
{
throw new InvalidOperationException(Strings.PackagesCouldNotBeInstalled, ex);
}
else
{
throw new InvalidOperationException(ex.Message, ex);
}
}
return nuGetProjectActions;
}
/// <summary>
/// Preview update actions for single package
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
private async Task PreviewAndExecuteUpdateActionsforSinglePackage(NuGetProject project)
{
var token = CancellationToken.None;
PackageReference installedPackage = (await project.GetInstalledPackagesAsync(token))
.Where(p => string.Equals(p.PackageIdentity.Id, Id, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// If package Id exists in Packages folder but is not actually installed to the current project, throw.
if (installedPackage == null)
{
Log(MessageLevel.Error, string.Format(Resources.PackageNotInstalledInAnyProject, Id));
}
else
{
// If -Version switch is specified
if (!string.IsNullOrEmpty(Version))
{
PackageIdentity update = GetUpdatePackageIdentityWhenVersionSpecified(project, installedPackage);
if (update != null)
{
// Update by package identity
await InstallPackageByIdentityAsync(project, update, ResolutionContext, this, WhatIf.IsPresent, Reinstall.IsPresent, UninstallContext);
}
else
{
Log(MessageLevel.Info, string.Format(Resources.Cmdlet_NoPackageUpdates, project.GetMetadata <string>(NuGetProjectMetadataKeys.Name)));
}
}
else
{
if (Reinstall.IsPresent)
{
// Update-Package Id -Reinstall
PackageIdentity identity = installedPackage.PackageIdentity;
await InstallPackageByIdentityAsync(project, identity, ResolutionContext, this, WhatIf.IsPresent, Reinstall.IsPresent, UninstallContext);
}
else
{
// Update-Package Id
NormalizePackageId(project);
NuGetVersion latestVersion = PowerShellCmdletsUtility.GetLastestVersionForPackageId(ActiveSourceRepository, Id, project, _allowPrerelease);
if (latestVersion > installedPackage.PackageIdentity.Version)
{
await InstallPackageByIdAsync(project, Id, ResolutionContext, this, WhatIf.IsPresent, Reinstall.IsPresent, UninstallContext);
}
else
{
Log(MessageLevel.Info, string.Format(Resources.Cmdlet_NoPackageUpdates, project.GetMetadata <string>(NuGetProjectMetadataKeys.Name)));
}
}
}
}
}
