/// <summary>
/// Attempts to find the package with given id and update its version number.
/// </summary>
/// <param name="packageId">Id of the package to change the version of</param>
/// <param name="version">Version number to assign</param>
/// <returns>
/// True if package was found and the version number corresponds to a valid semantic version.
/// False otherwise.
/// </returns>
/// <remarks>This method is safe to call simultaneously from multiple threads.</remarks>
public bool TryUpdatePackage(string packageId, NuGetVersion version, out NuGetVersion?existingVersion)
{
if (!_packageXElements.TryGetValue(packageId, out XElement? xElement))
{
existingVersion = default;
return(false);
}
lock (xElement)
{
string existingVersionStr = xElement.Attribute("version").Value;
if (!NuGetVersion.TryParse(existingVersionStr, out existingVersion))
{
return(false);
}
if (existingVersion >= version)
{
// Package was found. But no version update was necessary
return(true);
}
// Update the version
xElement.Attribute("version").Value = version.ToFullString();
}
// Store the document. Store a junk value (0) with it, because we have to.
_modifiedDocuments[xElement.Document] = 0;
return(true);
}
public static LeafInfo New(NuGetVersion version)
{
return(new LeafInfo(version, new RegistrationLeafItem
{
CatalogEntry = new RegistrationCatalogEntry
{
Version = version.ToFullString(),
}
}));
}
internal static string ToString(NuGetVersion version, NuGetVersionConversionFlags flags)
{
var versionString = ((flags & NuGetVersionConversionFlags.IncludeBuildMetadata) == 0)
? version.ToNormalizedString()
: version.ToFullString();
return(((flags & NuGetVersionConversionFlags.OriginalCasing) == 0)
? versionString.ToLowerInvariant()
: versionString);
}
public void NuGetVersionParseStrict(string versionString)
{
// Arrange
NuGetVersion semVer = null;
NuGetVersion.TryParseStrict(versionString, out semVer);
// Assert
Assert.Equal <string>(versionString, semVer.ToFullString());
Assert.Equal <string>(semVer.ToNormalizedString(), semVer.ToString());
}
private static ValidationResult ValidateDependencyVersion(NuGetVersion version)
{
if (version.HasMetadata)
{
return(new ValidationResult(string.Format(
CultureInfo.CurrentCulture,
CoreStrings.Manifest_InvalidDependencyVersion,
version.ToFullString())));
}
return(ValidateVersionForLegacyClients(version));
}
public void AvailableVersionCompareNextTest()
{
NuGetVersion currentVersion = new NuGetVersion(
VersionInfo.CurrentVersion.Major,
VersionInfo.CurrentVersion.Minor,
VersionInfo.CurrentVersion.Patch,
VersionInfo.CurrentVersion.Revision + 1,
#pragma warning disable CS0436 // Type conflicts with imported type
ThisAssembly.IsPublicRelease ? VersionInfo.CurrentVersion.ReleaseLabels :
#pragma warning restore CS0436 // Type conflicts with imported type
VersionInfo.CurrentVersion.ReleaseLabels.Concat(new string[] { "g" + VersionInfo.CurrentVersion.Metadata }), string.Empty);
NuGetVersion available = VersionInfo.GetBestAvailableVersion(new NuGetVersion[] { currentVersion }, true);
Assert.IsNotNull(available);
Assert.AreEqual(-1, VersionInfo.Compare(available.ToFullString()));
}
private async Task <string> ResolveNuGetVersion(PackageId packageId)
{
NuGetVersion resolvedVersion = null;
if (!UpdatePackages)
{
resolvedVersion = await GetLatestMatchingVersion(packageId, _localRepositoryProvider.Repositories, _nuGetLogger);
}
if (resolvedVersion == null && _repositoryProvider.Repositories.Count > 0)
{
resolvedVersion = await GetLatestMatchingVersion(packageId, _repositoryProvider.Repositories, _nuGetLogger);
}
return(resolvedVersion == null ? null : resolvedVersion.ToFullString());
}
public void WillSendEmailToAllOwners(string version)
{
// Arrange
var nugetVersion = new NuGetVersion(version);
var packageRegistration = new PackageRegistration
{
Id = "smangit",
Owners = new[]
{
new User {
EmailAddress = "*****@*****.**", NotifyPackagePushed = true
},
new User {
EmailAddress = "*****@*****.**", NotifyPackagePushed = true
}
}
};
var package = new Package
{
Version = version,
PackageRegistration = packageRegistration
};
packageRegistration.Packages.Add(package);
// Act
var messageService = TestableMessageService.Create(
GetService <AuthenticationService>(),
GetConfigurationService());
var packageUrl = $"https://localhost/packages/{packageRegistration.Id}/{nugetVersion.ToNormalizedString()}";
var supportUrl = $"https://localhost/packages/{packageRegistration.Id}/{nugetVersion.ToNormalizedString()}/ReportMyPackage";
var emailSettingsUrl = "https://localhost/account";
messageService.SendPackageAddedNotice(package, packageUrl, supportUrl, emailSettingsUrl);
// Assert
var message = messageService.MockMailSender.Sent.Last();
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("*****@*****.**", message.To[1].Address);
Assert.Equal(TestGalleryNoReplyAddress, message.From);
Assert.Contains($"[Joe Shmoe] Package published - {packageRegistration.Id} {nugetVersion.ToNormalizedString()}", message.Subject);
Assert.Contains(
$"The package [{packageRegistration.Id} {nugetVersion.ToFullString()}]({packageUrl}) was just published on Joe Shmoe. If this was not intended, please [contact support]({supportUrl}).", message.Body);
}
private static ValidationResult ValidateVersion(NuGetVersion version)
{
if (version.IsSemVer2)
{
return(new ValidationResult(string.Format(
CultureInfo.CurrentCulture,
CoreStrings.Manifest_InvalidVersionSemVer200,
version.ToFullString())));
}
else if (!version.IsValidVersionForLegacyClients())
{
return(new ValidationResult(string.Format(
CultureInfo.CurrentCulture,
CoreStrings.Manifest_InvalidVersion,
version)));
}
return(null);
}
public void Constructor_DeserializesSemVer2Version()
{
// Arrange
var cacheFile = "{\"SchemaVersion\":\"3.0.0\",\"Packages\":[{\"Id\":\"" + PackageId + "\",\"Version\":\"" + SemVer2VersionString + "\"}]}";
var fileSystem = new Mock <IFileSystem>();
fileSystem
.Setup(x => x.FileExists(CacheFileName))
.Returns(true);
fileSystem
.Setup(x => x.OpenFile(CacheFileName))
.Returns(() => new MemoryStream(Encoding.UTF8.GetBytes(cacheFile)));
// Act
var actual = new ServerPackageStore(fileSystem.Object, CacheFileName);
// Assert
Assert.Equal(1, actual.GetAll().Count());
var package = actual.GetAll().First();
Assert.Equal(SemVer2Version.ToString(), package.Version.ToString());
Assert.Equal(SemVer2Version.ToFullString(), package.Version.ToFullString());
Assert.Equal(SemVer2Version.ToNormalizedString(), package.Version.ToNormalizedString());
}
private void UpdateCatalogEntry(
HiveType hive,
string id,
Protocol.Registration.RegistrationCatalogEntry catalogEntry,
PackageDetailsCatalogLeaf packageDetails,
NuGetVersion parsedVersion)
{
catalogEntry.Url = packageDetails.Url;
catalogEntry.Type = JsonLdConstants.RegistrationLeafItemCatalogEntryType;
catalogEntry.Authors = packageDetails.Authors ?? string.Empty;
// Add the "registration" property to each package dependency.
if (packageDetails.DependencyGroups != null)
{
catalogEntry.DependencyGroups = new List <RegistrationPackageDependencyGroup>();
foreach (var group in packageDetails.DependencyGroups)
{
var registrationGroup = new RegistrationPackageDependencyGroup
{
Url = group.Url,
Type = group.Type,
TargetFramework = group.TargetFramework,
};
catalogEntry.DependencyGroups.Add(registrationGroup);
if (group.Dependencies == null)
{
continue;
}
registrationGroup.Dependencies = new List <RegistrationPackageDependency>();
for (int i = 0; i < group.Dependencies.Count; i++)
{
var catalogDependency = group.Dependencies[i];
var registrationDependency = new RegistrationPackageDependency
{
Url = catalogDependency.Url,
Type = catalogDependency.Type,
Id = catalogDependency.Id,
Range = catalogDependency.Range,
Registration = _urlBuilder.GetIndexUrl(hive, catalogDependency.Id),
};
registrationGroup.Dependencies.Add(registrationDependency);
}
}
}
else
{
catalogEntry.DependencyGroups = null;
}
// Add the types to the deprecation.
if (hive == HiveType.Legacy || hive == HiveType.Gzipped)
{
catalogEntry.Deprecation = null;
}
else
{
catalogEntry.Deprecation = packageDetails.Deprecation;
if (catalogEntry.Deprecation != null)
{
catalogEntry.Deprecation.Type = JsonLdConstants.PackageDeprecationType;
if (catalogEntry.Deprecation.AlternatePackage != null)
{
catalogEntry.Deprecation.AlternatePackage.Type = JsonLdConstants.AlternatePackageType;
}
}
}
catalogEntry.Description = packageDetails.Description ?? string.Empty;
if (!string.IsNullOrWhiteSpace(packageDetails.IconUrl) ||
!string.IsNullOrWhiteSpace(packageDetails.IconFile))
{
catalogEntry.IconUrl = GetPackageIconUrl(id, packageDetails);
}
else
{
catalogEntry.IconUrl = string.Empty;
}
catalogEntry.PackageId = packageDetails.PackageId ?? id;
catalogEntry.Language = packageDetails.Language ?? string.Empty;
catalogEntry.LicenseExpression = packageDetails.LicenseExpression ?? string.Empty;
if (!string.IsNullOrWhiteSpace(packageDetails.LicenseFile) ||
!string.IsNullOrWhiteSpace(packageDetails.LicenseExpression))
{
// Use the package ID casing from this specific version, since license URLs do not exclusively use
// lowercase package ID like icon URL. This is legacy behavior that can be revisited later. Gallery
// supports case insensitive package IDs so it doesn't matter too much.
catalogEntry.LicenseUrl = LicenseHelper.GetGalleryLicenseUrl(
catalogEntry.PackageId,
parsedVersion.ToNormalizedString(), _galleryBaseUrl);
}
else
{
catalogEntry.LicenseUrl = packageDetails.LicenseUrl ?? string.Empty;
}
catalogEntry.Listed = packageDetails.IsListed();
catalogEntry.MinClientVersion = packageDetails.MinClientVersion ?? string.Empty;
catalogEntry.PackageContent = GetPackageContentUrl(id, packageDetails);
catalogEntry.ProjectUrl = packageDetails.ProjectUrl ?? string.Empty;
catalogEntry.Published = packageDetails.Published;
catalogEntry.RequireLicenseAcceptance = packageDetails.RequireLicenseAcceptance ?? false;
catalogEntry.Summary = packageDetails.Summary ?? string.Empty;
if (packageDetails.Tags != null && packageDetails.Tags.Count > 0)
{
catalogEntry.Tags = packageDetails.Tags;
}
else
{
catalogEntry.Tags = new List <string> {
string.Empty
};
}
catalogEntry.Title = packageDetails.Title ?? string.Empty;
catalogEntry.Version = parsedVersion.ToFullString();
if (hive == HiveType.SemVer2 &&
packageDetails.Vulnerabilities != null &&
packageDetails.Vulnerabilities.Count > 0)
{
catalogEntry.Vulnerabilities = packageDetails.Vulnerabilities.Select(v =>
new RegistrationPackageVulnerability()
{
AdvisoryUrl = v.AdvisoryUrl,
Severity = v.Severity
}
).ToList();
}
else
{
catalogEntry.Vulnerabilities = null;
}
}
public static SdkResultBase GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContextBase context, SdkResultFactoryBase factory)
{
// Cast the NuGet version since the caller does not want to consume NuGet classes directly
NuGetVersion parsedSdkVersion = (NuGetVersion)nuGetVersion;
// Stores errors and warnings for the result
ICollection <string> errors = new List <string>();
ICollection <string> warnings = new List <string>();
// Load NuGet settings and a path resolver
ISettings settings = Settings.LoadDefaultSettings(context.ProjectFilePath);
FallbackPackagePathResolver fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
string installedPath, installedVersion;
// Attempt to find a package if its already installed
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, sdk.Name, parsedSdkVersion, out installedPath, out installedVersion))
{
try
{
// Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files
IReadOnlyList <RestoreResultPair> results = RestoreRunnerEx.RunWithoutCommit(
context.ProjectFilePath,
sdk.Name,
parsedSdkVersion.ToFullString(),
settings,
new NuGetSdkLogger(context.Logger, warnings, errors))
.ConfigureAwait(continueOnCapturedContext: false)
.GetAwaiter()
.GetResult();
fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Look for a successful result, any errors are logged by NuGet
foreach (RestoreResult result in results.Select(i => i.Result).Where(i => i.Success))
{
// Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0)
LibraryIdentity installedPackage = result.GetAllInstalled().FirstOrDefault(i => i.Name.Equals(sdk.Name));
if (installedPackage != null)
{
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage.Name, installedPackage.Version, out installedPath, out installedVersion))
{
// This should never happen because we were told the package was successfully installed.
// If we can't find it, we probably did something wrong with the NuGet API
errors.Add(ResourceUtilities.FormatResourceString("CouldNotFindInstalledPackage", sdk));
}
}
else
{
// This should never happen because we were told the restore succeeded.
// If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API
errors.Add(ResourceUtilities.FormatResourceString("PackageWasNotInstalled", sdk, sdk.Name));
}
}
}
catch (Exception e)
{
errors.Add(e.Message);
}
}
if (errors.Count == 0)
{
return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings));
}
return(factory.IndicateFailure(errors, warnings));
}
public static string ToFullStringSafe(this NuGetVersion self)
{
return(self != null?self.ToFullString() : string.Empty);
}
