public static void InstallPackage(string subFolder, PackageReference package ) { var logger = LogManager.GetCurrentClassLogger(); string packagePath = Path.GetFullPath( Path.Combine( subFolder, FindRelativePathOfPackagesFolder( subFolder ) ) ); // TODO: Use NuGet API for this! logger.Info( "Installing nuget package " + package.PackageIdentity + " to " + Path.GetFullPath( packagePath ) ); var nugetExe = GetNugetExePath(); var processStartInfo = new ProcessStartInfo( nugetExe, "install " + package.PackageIdentity.Id + " -Version " + package.PackageIdentity.Version + " -Pre" ); processStartInfo.RedirectStandardOutput = true; processStartInfo.RedirectStandardError = true; Directory.CreateDirectory( packagePath ); processStartInfo.WorkingDirectory = packagePath; processStartInfo.UseShellExecute = false; processStartInfo.CreateNoWindow = true; var process = Process.Start( processStartInfo ); logger.Info( process.StandardOutput.ReadToEnd() ); logger.Info( process.StandardError.ReadToEnd() ); if ( process.ExitCode != 0 ) { var exception = new Exception( "Failed to execute " + processStartInfo.FileName + " " + processStartInfo.Arguments ); logger.Error( exception ); throw exception; } }
public ConfigitPackageReference( string id, string version, string targetFramework = null, string allowedVersion = null, bool userInstalled = false ) { _reference = new PackageReference( new PackageIdentity( id, new NuGetVersion( version ) ), targetFramework == null ? null : new NuGetFramework( targetFramework ), userInstalled, false, false, allowedVersion != null ? VersionRange.Parse( allowedVersion ) : null ); }
void CreatePackageReference ( string packageId = "Id", string packageVersion = "1.2.3", bool requireReinstallation = false) { var version = new NuGetVersion (packageVersion); var identity = new PackageIdentity (packageId, version); packageReference = new PackageReference (identity, null, true, false, requireReinstallation); }
// TODO: Consider removing elements from the collection and check if that is better in performance public static IEnumerable<SourceDependencyInfo> RemoveDisallowedVersions(IEnumerable<SourceDependencyInfo> packages, PackageReference packageReference) { if (packageReference.AllowedVersions != null) { return packages.Where(p => !StringComparer.OrdinalIgnoreCase.Equals(p.Id, packageReference.PackageIdentity.Id) || packageReference.AllowedVersions.Satisfies(p.Version)); } return packages; }
public PackageReference ReTarget( PackageReference reference ) { if ( !IsTargeted( reference.PackageIdentity.Id ) ) { return reference; } return new PackageReference( new PackageIdentity( reference.PackageIdentity.Id, TargetVersion ?? reference.PackageIdentity.Version ), TargetFramework ?? reference.TargetFramework, reference.IsUserInstalled, reference.IsDevelopmentDependency, reference.RequireReinstallation ); }
public void AddPackageReference (string id, string version, VersionRange versionRange = null) { var packageId = new PackageIdentity (id, new NuGetVersion (version)); var packageReference = new PackageReference ( packageId, new NuGetFramework ("net45"), true, false, false, versionRange ); InstalledPackages.Add (packageReference); }
#pragma warning restore 67 public void RaisePackageRestoreFailedEvent (Exception exception, string projectName) { var packageReference = new PackageReference ( new PackageIdentity ("Test", new NuGetVersion ("1.2")), new NuGetFramework ("any") ); var eventArgs = new PackageRestoreFailedEventArgs ( packageReference, exception, new [] { projectName } ); PackageRestoreFailedEvent?.Invoke (this, eventArgs); }
public async Task GetInstalledPackagesAsync_WhenProjectReturnsNullPackageReference_NullIsRemoved() { const string projectName = "a"; string projectId = Guid.NewGuid().ToString(); using (TestDirectory testDirectory = TestDirectory.Create()) { Initialize(); string projectFullPath = Path.Combine(testDirectory.Path, $"{projectName}.csproj"); NuGetFramework targetFramework = NuGetFramework.Parse("net46"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext()); var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, testDirectory.Path, projectFullPath, projectId); var packageReference = new PackageReference( new PackageIdentity(id: "b", NuGetVersion.Parse("1.0.0")), targetFramework); project.InstalledPackageReferences = Task.FromResult <IEnumerable <PackageReference> >(new[] { null, packageReference }); _solutionManager.NuGetProjects.Add(project); var telemetrySession = new Mock <ITelemetrySession>(); var telemetryEvents = new ConcurrentQueue <TelemetryEvent>(); telemetrySession .Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(x => telemetryEvents.Enqueue(x)); TelemetryActivity.NuGetTelemetryService = new NuGetVSTelemetryService(telemetrySession.Object); IReadOnlyCollection <IPackageReferenceContextInfo> packages = await _projectManager.GetInstalledPackagesAsync( new[] { projectId }, CancellationToken.None); Assert.Equal(1, packages.Count); IPackageReferenceContextInfo expected = PackageReferenceContextInfo.Create(packageReference); IPackageReferenceContextInfo actual = packages.Single(); Assert.Equal(expected.AllowedVersions, actual.AllowedVersions); Assert.Equal(expected.Framework, actual.Framework); Assert.Equal(expected.Identity, actual.Identity); Assert.Equal(expected.IsAutoReferenced, actual.IsAutoReferenced); Assert.Equal(expected.IsDevelopmentDependency, actual.IsDevelopmentDependency); Assert.Equal(expected.IsUserInstalled, actual.IsUserInstalled); Assert.Equal(1, telemetryEvents.Count); } }
public void AddUnrestoredPackageForProject (string projectName, string solutionDirectory) { var packageReference = new PackageReference ( new PackageIdentity ("Test", new NuGetVersion ("1.0")), new NuGetFramework ("any")); var restoreData = new PackageRestoreData ( packageReference, new [] { projectName }, isMissing: true); var restoreDataList = new List<PackageRestoreData> (); restoreDataList.Add (restoreData); PackagesInSolution[solutionDirectory] = restoreDataList; }
private XElement ReplacePackageAttributes(XElement existingNode, PackageReference newEntry) { var newEntryNode = CreateXElementForPackageEntry(newEntry); var newAttributeNames = newEntryNode.Attributes().Select(a => a.Name); var existingAttributeNames = existingNode.Attributes().Select(a => a.Name); var addableAttributeNames = newAttributeNames.Except(existingAttributeNames); foreach (XName name in existingAttributeNames) { // Clear newValue string newValue = null; // Try to get newValue correlated to the attribute on the existing node. PackagesConfig.TryGetAttribute(newEntryNode, name.LocalName, out newValue); // When the attribute is not specified a value in the new node if (string.IsNullOrEmpty(newValue)) { if (name.Equals(XName.Get(PackagesConfig.RequireInstallAttributeName))) { // Remove the requirementReinstallation attribute. existingNode.SetAttributeValue(name, value: null); } else { // no-op. Keep the allowedVersion attribute and all other attributes as-is. } } else { // Replace existing attributes with new values existingNode.SetAttributeValue(name, newValue); } } // Add new attributes that was not in the old package reference entry, if any foreach (XName name in addableAttributeNames) { var attribute = new XAttribute(name, newEntryNode.Attribute(name).Value); existingNode.Add(attribute); } return(existingNode); }
public PackageObject(NuGet.Packaging.PackageReference packageReference, FrameworkName frameworkName) { _packageReference = packageReference; FrameworkName = frameworkName; Id = _packageReference.PackageIdentity.Id; Version = _packageReference.PackageIdentity.Version.Version; TextVersion = _packageReference.PackageIdentity.Version.ToString(); //todo //FrameworkAssemblies = package.FrameworkAssemblies // .Where(x => x.SupportedFrameworks.Any(y => y == frameworkName)) // .Select(x => x.AssemblyName); //todo //var dependencies = _packageReference..GetCompatiblePackageDependencies(frameworkName); //if (dependencies != null) //{ // Dependencies = dependencies.Select(i => new PackageObject(i.Id) { FrameworkName = frameworkName }); //} }
/// <summary> /// Adds a package entry to the file /// </summary> /// <param name="entry">Package reference entry</param> public void WritePackageEntry(PackageReference entry) { if (entry == null) { throw new ArgumentNullException("entry"); } if (_disposed || _closed) { throw new PackagingException("Writer closed. Unable to add entry."); } if (_entries.Where(e => StringComparer.OrdinalIgnoreCase.Equals(e.PackageIdentity.Id, entry.PackageIdentity.Id)).Any()) { throw new PackagingException(String.Format(CultureInfo.InvariantCulture, "Package entry already exists. Id: {0}", entry.PackageIdentity.Id)); } _entries.Add(entry); }
/// <summary> /// Update a package entry using the original entry as a base if it exists. /// </summary> public void UpdateOrAddPackageEntry(XDocument originalConfig, PackageReference newEntry) { if (originalConfig == null) { throw new ArgumentNullException(nameof(originalConfig)); } if (newEntry == null) { throw new ArgumentNullException(nameof(newEntry)); } if (_disposed) { throw new PackagesConfigWriterException(string.Format(CultureInfo.CurrentCulture, Strings.UnableToAddEntry)); } var originalPackagesNode = originalConfig.Element(XName.Get(PackagesConfig.PackagesNodeName)); XElement matchingIdNode; if (PackagesConfig.HasAttributeValue( originalPackagesNode, PackagesConfig.IdAttributeName, newEntry.PackageIdentity.Id, out matchingIdNode)) { // Find the old entry and update it based on the new entry var packagesNode = _xDocument.Element(XName.Get(PackagesConfig.PackagesNodeName)); var newPackageNode = ReplacePackageAttributes(matchingIdNode, newEntry); packagesNode.Add(newPackageNode); SortPackageNodes(packagesNode); } else { // There was no existing entry, add a new one AddPackageEntry(newEntry); } }
public static FrameworkedHintPath ReconstructHintPath( string assemblyFilePath, PackageIdentity oldPackageIdentity, PackageReference newestPackage, Reference reference ) { var parts = assemblyFilePath.Split( Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar ).ToList(); var newFramework = parts.Select( NuGetFramework.Parse ).FirstOrDefault( f => !f.IsUnsupported ); var hintParts = reference.HintPath.Split( Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar ).ToList(); var oldFramework = hintParts.Select( NuGetFramework.Parse ).FirstOrDefault( f => !f.IsUnsupported ); List<string> resultPath = new List<string>(); for ( int i = hintParts.Count - 1; i >= 0; i-- ) { if ( hintParts[i].StartsWith( "$" ) ) { resultPath.Add( hintParts[i] ); } else if ( hintParts[i].Equals( oldPackageIdentity.ToFolderName() ) ) { resultPath.Add( newestPackage.ToFolderName() ); } else if ( oldFramework != null && newFramework != null && hintParts[i].Equals( oldFramework.GetShortFolderName(), StringComparison.OrdinalIgnoreCase ) ) { resultPath.Add( newFramework.GetShortFolderName() ); } else { resultPath.Add( hintParts[i] ); } } resultPath.Reverse(); return new FrameworkedHintPath { Framework = newFramework, HintPath = Path.Combine( resultPath.ToArray() ) }; }
private XElement CreateXElementForPackageEntry(PackageReference entry) { var node = new XElement(XName.Get(PackagesConfig.PackageNodeName)); node.Add(new XAttribute(XName.Get(PackagesConfig.IdAttributeName), entry.PackageIdentity.Id)); node.Add(new XAttribute(XName.Get(PackagesConfig.VersionAttributeName), entry.PackageIdentity.Version)); // map the framework to the short name // special frameworks such as any and unsupported will be ignored here if (entry.TargetFramework.IsSpecificFramework) { var frameworkShortName = entry.TargetFramework.GetShortFolderName(_frameworkMappings); if (!String.IsNullOrEmpty(frameworkShortName)) { node.Add(new XAttribute(XName.Get(PackagesConfig.TargetFrameworkAttributeName), frameworkShortName)); } } if (entry.HasAllowedVersions) { node.Add(new XAttribute(XName.Get(PackagesConfig.allowedVersionsAttributeName), entry.AllowedVersions.ToString())); } if (entry.IsDevelopmentDependency) { node.Add(new XAttribute(XName.Get(PackagesConfig.developmentDependencyAttributeName), "true")); } if (entry.RequireReinstallation) { node.Add(new XAttribute(XName.Get(PackagesConfig.RequireInstallAttributeName), "true")); } return(node); }
void CreatePackageReferenceWithProjectJsonWildcardVersion (string packageId, string version) { packageReference = TestPackageReferenceFactory.CreatePackageReferenceWithProjectJsonWildcardVersion ( packageId, version); }
/// <summary> /// Reads all package node entries in the config /// </summary> /// <returns></returns> public IEnumerable <PackageReference> GetPackages() { var packages = new List <PackageReference>(); foreach (var package in _doc.Root.Elements(XName.Get("package"))) { string id = null; if (!TryGetAttribute(package, "id", out id) || String.IsNullOrEmpty(id)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorNullOrEmptyPackageId)); } string version = null; if (!TryGetAttribute(package, "version", out version) || String.IsNullOrEmpty(version)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidPackageVersion, id, version)); } NuGetVersion semver = null; if (!NuGetVersion.TryParse(version, out semver)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidPackageVersion, id, version)); } string attributeValue = null; VersionRange allowedVersions = null; if (TryGetAttribute(package, "allowedVersions", out attributeValue)) { if (!VersionRange.TryParse(attributeValue, out allowedVersions)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidAllowedVersions, id, attributeValue)); } } var targetFramework = NuGetFramework.UnsupportedFramework; if (TryGetAttribute(package, "targetFramework", out attributeValue)) { targetFramework = NuGetFramework.Parse(attributeValue, _frameworkMappings); } var developmentDependency = BoolAttribute(package, "developmentDependency"); var requireReinstallation = BoolAttribute(package, "requireReinstallation"); var userInstalled = BoolAttribute(package, "userInstalled", true); var entry = new PackageReference(new PackageIdentity(id, semver), targetFramework, userInstalled, developmentDependency, requireReinstallation, allowedVersions); packages.Add(entry); } // check if there are duplicate entries var packageIds = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var duplicates = new List <string>(); foreach (var package in packages) { if (packageIds.Contains(package.PackageIdentity.Id)) { duplicates.Add(package.PackageIdentity.Id); } else { packageIds.Add(package.PackageIdentity.Id); } } if (duplicates.Count > 0) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorDuplicatePackages, string.Join(", ", duplicates))); } return(packages); }
/// <summary> /// Adds a package entry to the file /// </summary> /// <param name="entry">Package reference entry</param> public void WritePackageEntry(PackageReference entry) { if (entry == null) { throw new ArgumentNullException("entry"); } if (_disposed || _closed) { throw new PackagingException("Writer closed. Unable to add entry."); } if (_entries.Where(e => StringComparer.OrdinalIgnoreCase.Equals(e.PackageIdentity.Id, entry.PackageIdentity.Id)).Any()) { throw new PackagingException(String.Format(CultureInfo.InvariantCulture, "Package entry already exists. Id: {0}", entry.PackageIdentity.Id)); } _entries.Add(entry); }
/// <summary> /// Adds a basic package entry to the file /// </summary> public void WritePackageEntry(PackageIdentity identity, NuGetFramework targetFramework) { var entry = new PackageReference(identity, targetFramework); WritePackageEntry(entry); }
public static Tuple<NuGetFramework, Reference> TryUpdateReference( string newFile, PackageIdentity oldPackageIdentity, PackageReference newestPackage, Reference reference, Func<string, AssemblyName> assemblyNameResolve = null ) { assemblyNameResolve = assemblyNameResolve ?? AssemblyName.GetAssemblyName; var newHintPath = ReconstructHintPath( newFile, oldPackageIdentity, newestPackage, reference ); if ( newHintPath == null ) { return null; } AssemblyName updatedName = assemblyNameResolve( newFile ); string updatedInclude = IncludeFromAssemblyName( updatedName ); return new Tuple<NuGetFramework, Reference>( newHintPath.Framework, new Reference( updatedInclude, reference.SpecificVersion, reference.Private, newHintPath.HintPath ) ); }
async Task<PackageIdentity> GetUpdates (SourceRepository sourceRepository, PackageReference packageReference) { var metadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource> (cancellationToken); if (metadataResource == null) return null; var packages = await metadataResource.GetMetadataAsync ( packageReference.PackageIdentity.Id, includePrerelease: packageReference.PackageIdentity.Version.IsPrerelease, includeUnlisted: false, log: NullLogger.Instance, token: cancellationToken); var package = packages .Where (p => IsPackageVersionAllowed (p, packageReference)) .OrderByDescending (p => p.Identity.Version).FirstOrDefault (); if (package == null) return null; if (package.Identity.Version > packageReference.PackageIdentity.Version) return package.Identity; return null; }
/// <summary> /// Get update package identity when -Version is specified. /// </summary> /// <param name="project"></param> /// <param name="installedPackage"></param> /// <returns></returns> private PackageIdentity GetUpdatePackageIdentityWhenVersionSpecified(NuGetProject project, PackageReference installedPackage) { PackageIdentity update = null; // If Highest/HighestMinor/HighestPatch/Lowest is given after -version switch if (IsVersionEnum) { update = GetPackageUpdate(installedPackage, project, _allowPrerelease, false, null, true, _updateVersionEnum); } // If a NuGetVersion format is given after -version switch else { update = GetPackageUpdate(installedPackage, project, _allowPrerelease, false, Version); } return update; }
/// <summary> /// Reads all package node entries in the config /// </summary> /// <returns></returns> public IEnumerable<PackageReference> GetPackages() { var packages = new List<PackageReference>(); foreach (var package in _doc.Root.Elements(XName.Get("package"))) { string id = null; if (!TryGetAttribute(package, "id", out id) || String.IsNullOrEmpty(id)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorNullOrEmptyPackageId)); } string version = null; if (!TryGetAttribute(package, "version", out version) || String.IsNullOrEmpty(version)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidPackageVersion, id, version)); } NuGetVersion semver = null; if (!NuGetVersion.TryParse(version, out semver)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidPackageVersion, id, version)); } string attributeValue = null; VersionRange allowedVersions = null; if (TryGetAttribute(package, "allowedVersions", out attributeValue)) { if (!VersionRange.TryParse(attributeValue, out allowedVersions)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidAllowedVersions, id, attributeValue)); } } var targetFramework = NuGetFramework.UnsupportedFramework; if (TryGetAttribute(package, "targetFramework", out attributeValue)) { targetFramework = NuGetFramework.Parse(attributeValue, _frameworkMappings); } var developmentDependency = BoolAttribute(package, "developmentDependency"); var requireReinstallation = BoolAttribute(package, "requireReinstallation"); var userInstalled = BoolAttribute(package, "userInstalled", true); var entry = new PackageReference(new PackageIdentity(id, semver), targetFramework, userInstalled, developmentDependency, requireReinstallation, allowedVersions); packages.Add(entry); } // check if there are duplicate entries var packageIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var duplicates = new List<string>(); foreach (var package in packages) { if (packageIds.Contains(package.PackageIdentity.Id)) { duplicates.Add(package.PackageIdentity.Id); } else { packageIds.Add(package.PackageIdentity.Id); } } if (duplicates.Count > 0) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorDuplicatePackages, string.Join(", ", duplicates))); } return packages; }
bool IsPackageVersionAllowed (IPackageSearchMetadata package, PackageReference packageReference) { if (!packageReference.HasAllowedVersions) return true; return packageReference.AllowedVersions.Satisfies (package.Identity.Version); }
public override bool IsPackageInstalled (PackageReference reference) { return PackageReferencesWithPackageInstalled.Contains (reference); }
private bool UpgradePackagesConfig( ProjectPackages oldPackagesConfig, ProjectFile project ) { List<PackageReference> updatedPackages = new List<PackageReference>(); bool changed = false; var logger = LogManager.GetCurrentClassLogger(); foreach ( var package in oldPackagesConfig ) { var targetVersion = _packageIndex.GetTargetVersionOf( package.PackageIdentity.Id ); PackageReference newPackage = new PackageReference( new PackageIdentity( package.PackageIdentity.Id, targetVersion ), package.TargetFramework, package.IsUserInstalled, package.IsDevelopmentDependency, package.RequireReinstallation, package.AllowedVersions ); updatedPackages.Add( newPackage ); if ( targetVersion.Equals( package.PackageIdentity.Version ) ) { continue; } changed = true; logger.Info( project.Name + ": Changing " + package.PackageIdentity.Id + " version " + package.PackageIdentity.Version + " to " + targetVersion ); NuGetExtensions.InstallPackage( Path.GetDirectoryName( _projectFile ), newPackage ); } if ( !changed ) { return false; } var config = Path.Combine( Path.GetDirectoryName( _projectFile ), "packages.config" ); logger.Info( "Writing changes to " + config ); updatedPackages.Write( config ); return true; }
private ConfigitPackageReference( PackageReference reference ) { _reference = reference; }
/// <summary> /// Remove a package identity from the file /// </summary> /// <param name="identity">Package identity</param> /// <param name="targetFramework">Package targetFramework</param> public void RemovePackageEntry(PackageIdentity identity, NuGetFramework targetFramework) { var entry = new PackageReference(identity, targetFramework); RemovePackageEntry(entry); }
PackageReferenceNode CreatePackageReferenceNode (PackageReference reference, UpdatedNuGetPackagesInProject updatedPackages) { // Floating package references (e.g. 1.0.1-*) are shown as installed. // Currently the version being used can be found in the project.lock.json but // reading this is not currently supported. So for now the package is shown // as installed since without the full version it is not possible to check // the NuGet package exists. bool installed = reference.IsFloating () || IsPackageInstalled (reference); return new PackageReferenceNode ( this, reference, installed, false, updatedPackages.GetUpdatedPackage (reference.PackageIdentity.Id)); }
public virtual bool IsPackageInstalled (PackageReference reference) { if (IsNuGetIntegratedProject ()) { string path = packagePathResolver.GetHashPath (reference.PackageIdentity.Id, reference.PackageIdentity.Version); return File.Exists (path); } return folder.PackageExists (reference.PackageIdentity); }
private async Task<IEnumerable<NuGetProjectAction>> PreviewUninstallPackageAsyncPrivate(NuGetProject nuGetProject, PackageReference packageReference, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if(SolutionManager == null) { throw new InvalidOperationException(Strings.SolutionManagerNotAvailableForUninstall); } if (nuGetProject is ProjectManagement.Projects.ProjectKNuGetProjectBase) { var action = NuGetProjectAction.CreateUninstallProjectAction(packageReference.PackageIdentity); return new NuGetProjectAction[] { action }; } // Step-1 : Get the metadata resources from "packages" folder or custom repository path var packageIdentity = packageReference.PackageIdentity; var packageReferenceTargetFramework = packageReference.TargetFramework; nuGetProjectContext.Log(MessageLevel.Info, Strings.AttemptingToGatherDependencyInfo, packageIdentity, packageReferenceTargetFramework); // TODO: IncludePrerelease is a big question mark var installedPackageIdentities = (await nuGetProject.GetInstalledPackagesAsync(token)).Select(pr => pr.PackageIdentity); var dependencyInfoFromPackagesFolder = await GetDependencyInfoFromPackagesFolder(installedPackageIdentities, packageReferenceTargetFramework, includePrerelease: true); nuGetProjectContext.Log(MessageLevel.Info, Strings.ResolvingActionsToUninstallPackage, packageIdentity); // Step-2 : Determine if the package can be uninstalled based on the metadata resources var packagesToBeUninstalled = UninstallResolver.GetPackagesToBeUninstalled(packageIdentity, dependencyInfoFromPackagesFolder, installedPackageIdentities, uninstallationContext); var nuGetProjectActions = packagesToBeUninstalled.Select(p => NuGetProjectAction.CreateUninstallProjectAction(p)); nuGetProjectContext.Log(MessageLevel.Info, Strings.ResolvedActionsToUninstallPackage, packageIdentity); return nuGetProjectActions; }
/// <summary> /// Reads all package node entries in the config. /// </summary> /// <param name="allowDuplicatePackageIds">If True validation will be performed to ensure that /// only one entry exists for each unique package id.</param> public IEnumerable <PackageReference> GetPackages(bool allowDuplicatePackageIds) { var packages = new List <PackageReference>(); foreach (var package in _doc.Root.Elements(XName.Get(PackagesConfig.PackageNodeName))) { string id = null; if (!PackagesConfig.TryGetAttribute(package, "id", out id) || String.IsNullOrEmpty(id)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorNullOrEmptyPackageId)); } string version = null; if (!PackagesConfig.TryGetAttribute(package, PackagesConfig.VersionAttributeName, out version) || String.IsNullOrEmpty(version)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidPackageVersion, id, version)); } NuGetVersion semver = null; if (!NuGetVersion.TryParse(version, out semver)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidPackageVersion, id, version)); } string attributeValue = null; VersionRange allowedVersions = null; if (PackagesConfig.TryGetAttribute(package, PackagesConfig.allowedVersionsAttributeName, out attributeValue)) { if (!VersionRange.TryParse(attributeValue, out allowedVersions)) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorInvalidAllowedVersions, id, attributeValue)); } } var targetFramework = NuGetFramework.UnsupportedFramework; if (PackagesConfig.TryGetAttribute(package, PackagesConfig.TargetFrameworkAttributeName, out attributeValue)) { targetFramework = NuGetFramework.Parse(attributeValue, _frameworkMappings); } var developmentDependency = PackagesConfig.BoolAttribute(package, PackagesConfig.developmentDependencyAttributeName); var requireReinstallation = PackagesConfig.BoolAttribute(package, PackagesConfig.RequireInstallAttributeName); var userInstalled = PackagesConfig.BoolAttribute(package, PackagesConfig.UserInstalledAttributeName, true); var entry = new PackageReference(new PackageIdentity(id, semver), targetFramework, userInstalled, developmentDependency, requireReinstallation, allowedVersions); packages.Add(entry); } // check if there are duplicate entries var duplicates = new HashSet <string>(StringComparer.OrdinalIgnoreCase); PackageIdentity lastIdentity = null; var comparer = PackageIdentity.Comparer; // Sort the list of packages and check for duplicates foreach (var package in packages.OrderBy(p => p.PackageIdentity, comparer)) { if (lastIdentity != null) { if (allowDuplicatePackageIds) { // Full compare if (comparer.Equals(package.PackageIdentity, lastIdentity)) { duplicates.Add(lastIdentity.ToString()); } } else if (string.Equals( package.PackageIdentity.Id, lastIdentity.Id, StringComparison.OrdinalIgnoreCase)) { // Id only compare duplicates.Add(lastIdentity.Id); } } lastIdentity = package.PackageIdentity; } if (duplicates.Count > 0) { throw new PackagesConfigReaderException(string.Format( CultureInfo.CurrentCulture, Strings.ErrorDuplicatePackages, string.Join(", ", duplicates))); } return(packages); }
private Reference UpdateReference( string projectFolder, string relativePackageFolder, PackageIdentity oldPackage, PackageReference newestPackage, Reference reference ) { var packageFolder = new DirectoryInfo( Path.GetFullPath( Path.Combine( projectFolder, relativePackageFolder, newestPackage.PackageIdentity.ToFolderName() ) ) ); if ( !packageFolder.Exists ) { throw new Exception( "The package " + newestPackage.PackageIdentity + " failed to install?" ); } var assemblyName = Path.GetFileName( reference.HintPath ); Tuple<NuGetFramework, Reference> bestUpdate = null; foreach ( var file in packageFolder.GetFiles( assemblyName, SearchOption.AllDirectories ) ) { var updatedReference = TryUpdateReference( file.FullName, oldPackage, newestPackage, reference ); if ( updatedReference == null ) { continue; } if ( updatedReference.Item1 == null ) { // If we donĀ“t know the target framework we cannot pick the best // TODO: Get from assembly file itself? bestUpdate = updatedReference; break; } if ( bestUpdate == null || updatedReference.Item1.Equals( newestPackage.TargetFramework ) ) { bestUpdate = updatedReference; } else if ( StringComparer.OrdinalIgnoreCase.Compare( bestUpdate.Item1.GetShortFolderName(), newestPackage.TargetFramework.GetShortFolderName() ) <= 0 ) { bestUpdate = updatedReference; } } if ( bestUpdate != null ) { LogManager.GetCurrentClassLogger().Info( "Updated: " + reference + " to: " + bestUpdate.Item2 ); return bestUpdate.Item2; } return null; }