private static string GetProjectSettingsKey(NuGetProject nuGetProject) { string projectName; if (!nuGetProject.TryGetMetadata(NuGetProjectMetadataKeys.Name, out projectName)) { projectName = "unknown"; } return("project:" + projectName); }
public static ValueTask <IProjectContextInfo> CreateAsync(NuGetProject nugetProject, CancellationToken cancellationToken) { Assumes.NotNull(nugetProject); if (!nugetProject.TryGetMetadata(NuGetProjectMetadataKeys.ProjectId, out string projectId)) { throw new InvalidOperationException(); } NuGetProjectKind projectKind = GetProjectKind(nugetProject); ProjectStyle projectStyle = nugetProject.ProjectStyle; return(new ValueTask <IProjectContextInfo>(new ProjectContextInfo(projectId, projectStyle, projectKind))); }
public PreviewResult( NuGetProject target, IEnumerable<PackageIdentity> added, IEnumerable<PackageIdentity> deleted, IEnumerable<UpdatePreviewResult> updated) { string s = null; if (target.TryGetMetadata<string>(NuGetProjectMetadataKeys.Name, out s)) { Name = s; } else { Name = "Unknown Project"; } Added = added; Deleted = deleted; Updated = updated; }
public PreviewResult( NuGetProject target, IEnumerable <PackageIdentity> added, IEnumerable <PackageIdentity> deleted, IEnumerable <UpdatePreviewResult> updated) { string s = null; if (target.TryGetMetadata <string>(NuGetProjectMetadataKeys.Name, out s)) { Name = s; } else { Name = "Unknown Project"; } Added = added; Deleted = deleted; Updated = updated; }
public PreviewResult( NuGetProject target, IEnumerable <AccessiblePackageIdentity> added, IEnumerable <AccessiblePackageIdentity> deleted, IEnumerable <UpdatePreviewResult> updated) { string s = null; if (target.TryGetMetadata(NuGetProjectMetadataKeys.UniqueName, out s)) { Name = s; } else { Name = Resources.Preview_UnknownProject; } Target = target; Added = added; Deleted = deleted; Updated = updated; }
async Task <Tuple <NuGetFramework, IEnumerable <PackageIdentity> > > CollectPackagesForPackagesConfigAsync( NuGetProject project, CancellationToken token) { token.ThrowIfCancellationRequested(); // Read packages.config var installedRefs = await project.GetInstalledPackagesAsync(token); if (installedRefs?.Any() == true) { // Index packages.config references by target framework since this affects dependencies NuGetFramework targetFramework; if (!project.TryGetMetadata(NuGetProjectMetadataKeys.TargetFramework, out targetFramework)) { targetFramework = NuGetFramework.AnyFramework; } return(Tuple.Create(targetFramework, installedRefs.Select(reference => reference.PackageIdentity))); } return(Tuple.Create(NuGetFramework.AnyFramework, Enumerable.Empty <PackageIdentity> ())); }
private async Task <bool> ExecuteCoreAsync( PackageIdentity packageIdentity, string fullScriptPath, string packageInstallPath, EnvDTEProject envDTEProject, NuGetProject nuGetProject, INuGetProjectContext nuGetProjectContext, bool throwOnFailure) { if (File.Exists(fullScriptPath)) { if (fullScriptPath.EndsWith(PowerShellScripts.Init, StringComparison.OrdinalIgnoreCase) && !TryMarkVisited(packageIdentity, PackageInitPS1State.FoundAndExecuted)) { return(true); } ScriptPackage package = null; if (envDTEProject != null) { NuGetFramework targetFramework; nuGetProject.TryGetMetadata(NuGetProjectMetadataKeys.TargetFramework, out targetFramework); // targetFramework can be null for unknown project types string shortFramework = targetFramework?.GetShortFolderName() ?? string.Empty; nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity, envDTEProject.Name, shortFramework); } if (packageIdentity != null) { package = new ScriptPackage(packageIdentity.Id, packageIdentity.Version.ToString(), packageInstallPath); } string toolsPath = Path.GetDirectoryName(fullScriptPath); IPSNuGetProjectContext psNuGetProjectContext = nuGetProjectContext as IPSNuGetProjectContext; if (psNuGetProjectContext != null && psNuGetProjectContext.IsExecuting && psNuGetProjectContext.CurrentPSCmdlet != null) { var psVariable = psNuGetProjectContext.CurrentPSCmdlet.SessionState.PSVariable; // set temp variables to pass to the script psVariable.Set("__rootPath", packageInstallPath); psVariable.Set("__toolsPath", toolsPath); psVariable.Set("__package", package); psVariable.Set("__project", envDTEProject); psNuGetProjectContext.ExecutePSScript(fullScriptPath, throwOnFailure); } else { string logMessage = String.Format(CultureInfo.CurrentCulture, Resources.ExecutingScript, fullScriptPath); // logging to both the Output window and progress window. nuGetProjectContext.Log(MessageLevel.Info, logMessage); try { await ExecuteScriptCoreAsync( package, packageInstallPath, fullScriptPath, toolsPath, envDTEProject); } catch (Exception ex) { // throwFailure is set by Package Manager. if (throwOnFailure) { throw; } nuGetProjectContext.Log(MessageLevel.Warning, ex.Message); } } return(true); } else { if (fullScriptPath.EndsWith(PowerShellScripts.Init, StringComparison.OrdinalIgnoreCase)) { TryMarkVisited(packageIdentity, PackageInitPS1State.NotFound); } } return(false); }
private async Task <bool> ExecuteCoreAsync( string fullScriptPath, string packageInstallPath, ZipArchive packageZipArchive, EnvDTEProject envDTEProject, NuGetProject nuGetProject, INuGetProjectContext nuGetProjectContext) { if (File.Exists(fullScriptPath)) { PackageIdentity packageIdentity = null; if (envDTEProject != null) { NuGetFramework targetFramework; nuGetProject.TryGetMetadata <NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework, out targetFramework); // targetFramework can be null for unknown project types string shortFramework = targetFramework == null ? string.Empty : targetFramework.GetShortFolderName(); var packageReader = new PackageReader(packageZipArchive); packageIdentity = packageReader.GetIdentity(); nuGetProjectContext.Log(MessageLevel.Debug, NuGet.ProjectManagement.Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity, envDTEProject.Name, shortFramework); //logger.Log(MessageLevel.Debug, NuGetResources.Debug_TargetFrameworkInfo_PowershellScripts, // Path.GetDirectoryName(scriptFile.Path), VersionUtility.GetTargetFrameworkLogString(scriptFile.TargetFramework)); } if (fullScriptPath.EndsWith(PowerShellScripts.Init, StringComparison.OrdinalIgnoreCase)) { _skipPSScriptExecution = await NuGetPackageManager.PackageExistsInAnotherNuGetProject(nuGetProject, packageIdentity, _solutionManager, CancellationToken.None); } else { _skipPSScriptExecution = false; } if (!_skipPSScriptExecution) { string toolsPath = Path.GetDirectoryName(fullScriptPath); IPSNuGetProjectContext psNuGetProjectContext = nuGetProjectContext as IPSNuGetProjectContext; if (psNuGetProjectContext != null && psNuGetProjectContext.IsExecuting && psNuGetProjectContext.CurrentPSCmdlet != null) { var psVariable = psNuGetProjectContext.CurrentPSCmdlet.SessionState.PSVariable; // set temp variables to pass to the script psVariable.Set("__rootPath", packageInstallPath); psVariable.Set("__toolsPath", toolsPath); psVariable.Set("__package", packageZipArchive); psVariable.Set("__project", envDTEProject); psNuGetProjectContext.ExecutePSScript(fullScriptPath); } else { string command = "$__pc_args=@(); $input|%{$__pc_args+=$_}; & " + PathUtility.EscapePSPath(fullScriptPath) + " $__pc_args[0] $__pc_args[1] $__pc_args[2] $__pc_args[3]; Remove-Variable __pc_args -Scope 0"; object[] inputs = new object[] { packageInstallPath, toolsPath, packageZipArchive, envDTEProject }; string logMessage = String.Format(CultureInfo.CurrentCulture, Resources.ExecutingScript, fullScriptPath); // logging to both the Output window and progress window. nuGetProjectContext.Log(MessageLevel.Info, logMessage); IConsole console = OutputConsoleProvider.CreateOutputConsole(requirePowerShellHost: true); Host.Execute(console, command, inputs); } return(true); } } return(false); }
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; }