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); } }