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);
}
}
private async void ExecuteUpgradeNuGetProjectCommandAsync(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (ShouldMEFBeInitialized())
{
await InitializeMEFAsync();
}
var project = EnvDTEProjectInfoUtility.GetActiveProject(VsMonitorSelection);
if (!await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(null, project))
{
MessageHelper.ShowWarningMessage(Resources.ProjectMigrateErrorMessage, Resources.ErrorDialogBoxTitle);
return;
}
var uniqueName = await EnvDTEProjectInfoUtility.GetCustomUniqueNameAsync(project);
// Close NuGet Package Manager if it is open for this project
var windowFrame = FindExistingWindowFrame(project);
windowFrame?.CloseFrame((uint)__FRAMECLOSE.FRAMECLOSE_SaveIfDirty);
var nuGetProject = await SolutionManager.Value.GetNuGetProjectAsync(uniqueName);
var uiController = ServiceLocator.GetInstance <INuGetUIFactory>().Create(nuGetProject);
var settings = uiController.UIContext.UserSettingsManager.GetSettings(GetProjectSettingsKey(nuGetProject));
await uiController.UIContext.UIActionEngine.UpgradeNuGetProjectAsync(uiController, nuGetProject);
uiController.UIContext.UserSettingsManager.PersistSettings();
}
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 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);
}
private async Task ExecuteUpgradeNuGetProjectCommandAsync(object sender, EventArgs e)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (ShouldMEFBeInitialized())
{
await InitializeMEFAsync();
}
var project = VsMonitorSelection.GetActiveProject();
if (!await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(null, project))
{
MessageHelper.ShowWarningMessage(Resources.ProjectMigrateErrorMessage, Resources.ErrorDialogBoxTitle);
return;
}
string uniqueName = await project.GetCustomUniqueNameAsync();
// Close NuGet Package Manager if it is open for this project
IVsWindowFrame windowFrame = await FindExistingWindowFrameAsync(project);
windowFrame?.CloseFrame((uint)__FRAMECLOSE.FRAMECLOSE_SaveIfDirty);
IServiceBroker serviceBroker = await ServiceBrokerProvider.Value.GetAsync();
NuGetProject nuGetProject = await SolutionManager.Value.GetNuGetProjectAsync(uniqueName);
IProjectContextInfo projectContextInfo = await ProjectContextInfo.CreateAsync(nuGetProject, CancellationToken.None);
using (INuGetUI uiController = await UIFactory.Value.CreateAsync(serviceBroker, projectContextInfo))
{
await uiController.UIContext.UIActionEngine.UpgradeNuGetProjectAsync(uiController, projectContextInfo);
uiController.UIContext.UserSettingsManager.PersistSettings();
}
}
private bool IsPackagesConfigSelected()
{
return(NuGetProjectUpgradeUtility.IsPackagesConfigSelected(VsMonitorSelection));
}
/// <summary>
/// Internal install method. All installs from the VS API and template wizard end up here.
/// </summary>
internal async Task InstallInternalAsync(
Project project,
List <PackageIdentity> packages,
ISourceRepositoryProvider repoProvider,
VSAPIProjectContext projectContext,
bool includePrerelease,
bool ignoreDependencies,
CancellationToken token)
{
// Go off the UI thread. This may be called from the UI thread. Only switch to the UI thread where necessary
// This method installs multiple packages and can likely take more than a few secs
// So, go off the UI thread explicitly to improve responsiveness
await TaskScheduler.Default;
var gatherCache = new GatherCache();
var sources = repoProvider.GetRepositories().ToList();
// store expanded node state
var expandedNodes = await VsHierarchyUtility.GetAllExpandedNodesAsync();
try
{
var depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
var packageManager = CreatePackageManager(repoProvider);
// find the project
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext);
var packageManagementFormat = new PackageManagementFormat(_settings);
// 1 means PackageReference
var preferPackageReference = packageManagementFormat.SelectedPackageManagementFormat == 1;
// Check if default package format is set to `PackageReference` and project has no
// package installed yet then upgrade it to `PackageReference` based project.
if (preferPackageReference &&
(nuGetProject is MSBuildNuGetProject) &&
!(await nuGetProject.GetInstalledPackagesAsync(token)).Any() &&
await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject, project, needsAPackagesConfig: false))
{
nuGetProject = await _solutionManager.UpgradeProjectToPackageReferenceAsync(nuGetProject);
}
// install the package
foreach (var package in packages)
{
var installedPackageReferences = await nuGetProject.GetInstalledPackagesAsync(token);
// Check if the package is already installed
if (package.Version != null &&
PackageServiceUtilities.IsPackageInList(installedPackageReferences, package.Id, package.Version))
{
continue;
}
// Perform the install
await InstallInternalCoreAsync(
packageManager,
gatherCache,
nuGetProject,
package,
sources,
projectContext,
includePrerelease,
ignoreDependencies,
token);
}
}
finally
{
// collapse nodes
await VsHierarchyUtility.CollapseAllNodesAsync(expandedNodes);
}
}
private async Task <bool> IsProjectUpgradeableAsync()
{
return(await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(null, EnvDTEProjectInfoUtility.GetActiveProject(VsMonitorSelection)));
}
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();
var isUpgradable = await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject);
return(new ProjectTelemetryEvent(
NuGetVersion.Value,
projectId,
projectType,
installedPackagesCount,
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);
}
}
/// <summary>
/// Installs one or more packages into the specified project.
/// </summary>
/// <param name="packageInstaller">The package installer service that performs the actual package installation.</param>
/// <param name="project">The target project for installation.</param>
/// <param name="configuration">
/// The packages to install, where to install them from, and additional options for
/// their installation.
/// </param>
/// <param name="repositorySettings">The repository settings for the packages being installed.</param>
/// <param name="preferPackageReferenceFormat">Install packages to the project as PackageReference if the project type supports it</param>
/// <param name="warningHandler">
/// An action that accepts a warning message and presents it to the user, allowing
/// execution to continue.
/// </param>
/// <param name="errorHandler">
/// An action that accepts an error message and presents it to the user, allowing
/// execution to continue.
/// </param>
internal async Task PerformPackageInstallAsync(
IVsPackageInstaller packageInstaller,
EnvDTE.Project project,
PreinstalledPackageConfiguration configuration,
bool preferPackageReferenceFormat,
Action <string> warningHandler,
Action <string> errorHandler)
{
ThreadHelper.ThrowIfNotOnUIThread();
var repositoryPath = configuration.RepositoryPath;
var repositorySource = new Configuration.PackageSource(repositoryPath);
var failedPackageErrors = new List <string>();
// find the project
var defaultProjectContext = new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, defaultProjectContext);
if (preferPackageReferenceFormat && await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject, project, needsAPackagesConfig: false))
{
nuGetProject = await _solutionManager.UpgradeProjectToPackageReferenceAsync(nuGetProject);
}
// For BuildIntegratedNuGetProject, nuget will ignore preunzipped configuration.
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
var repository = (buildIntegratedProject == null && configuration.IsPreunzipped) ?
_sourceProvider.CreateRepository(repositorySource, FeedType.FileSystemUnzipped) :
_sourceProvider.CreateRepository(repositorySource);
var repoProvider = new PreinstalledRepositoryProvider(errorHandler, _sourceProvider);
repoProvider.AddFromSource(repository);
var packageManager = _installer.CreatePackageManager(repoProvider);
var gatherCache = new GatherCache();
var sources = repoProvider.GetRepositories().ToList();
// store expanded node state
var expandedNodes = await VsHierarchyUtility.GetAllExpandedNodesAsync();
try
{
foreach (var package in configuration.Packages)
{
var packageIdentity = new PackageIdentity(package.Id, package.Version);
// Does the project already have this package installed?
if (_packageServices.IsPackageInstalled(project, package.Id))
{
// If so, is it the right version?
if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToNormalizedString()))
{
// No? Raise a warning (likely written to the Output window) and ignore this package.
warningHandler(string.Format(VsResources.PreinstalledPackages_VersionConflict, package.Id, package.Version));
}
// Yes? Just silently ignore this package!
}
else
{
try
{
if (InfoHandler != null)
{
InfoHandler(string.Format(CultureInfo.CurrentCulture, VsResources.PreinstalledPackages_PackageInstallStatus, package.Id, package.Version));
}
// Skip assembly references and disable binding redirections should be done together
var disableBindingRedirects = package.SkipAssemblyReferences;
var projectContext = new VSAPIProjectContext(package.SkipAssemblyReferences, disableBindingRedirects);
var loggerAdapter = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, loggerAdapter),
loggerAdapter);
// This runs from the UI thread
await _installer.InstallInternalCoreAsync(
packageManager,
gatherCache,
nuGetProject,
packageIdentity,
sources,
projectContext,
includePrerelease : false,
ignoreDependencies : package.IgnoreDependencies,
token : CancellationToken.None);
}
catch (InvalidOperationException exception)
{
failedPackageErrors.Add(package.Id + "." + package.Version + " : " + exception.Message);
}
catch (AggregateException aggregateEx)
{
var ex = aggregateEx.Flatten().InnerExceptions.FirstOrDefault();
if (ex is InvalidOperationException)
{
failedPackageErrors.Add(package.Id + "." + package.Version + " : " + ex.Message);
}
else
{
throw;
}
}
}
}
if (failedPackageErrors.Any())
{
var errorString = new StringBuilder();
errorString.AppendFormat(VsResources.PreinstalledPackages_FailedToInstallPackage, repositoryPath);
errorString.AppendLine();
errorString.AppendLine();
errorString.Append(string.Join(Environment.NewLine, failedPackageErrors));
errorHandler(errorString.ToString());
}
// RepositorySettings = null in unit tests
if (project.IsWebSite())
{
CreateRefreshFilesInBin(
project,
repositoryPath,
configuration.Packages.Where(p => p.SkipAssemblyReferences));
CopyNativeBinariesToBin(project, repositoryPath, configuration.Packages);
}
}
finally
{
// collapse nodes
await VsHierarchyUtility.CollapseAllNodesAsync(expandedNodes);
}
}
public async Task <bool> IsNuGetProjectUpgradeable(NuGetProject project)
{
return(await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(project));
}
