public void IfToStringReturnName()
{
var package = new PackageVersion();
package.Name = "test";
Assert.AreEqual("Name", package.ToString().Substring(0, 4));
}
//----------------------------------------------------------------------------------------------------------------------
private void CreateAndCheckPackageVersion(string semanticVer, int major, int minor, int patch, PackageLifecycle lifecycle,
string additionalMetadata)
{
PackageVersion packageVersion = new PackageVersion(semanticVer);
Assert.AreEqual(major, packageVersion.Major);
Assert.AreEqual(minor, packageVersion.Minor);
Assert.AreEqual(patch, packageVersion.Patch);
Assert.AreEqual(lifecycle, packageVersion.Lifecycle);
Assert.AreEqual(additionalMetadata, packageVersion.AdditionalMetadata);
Assert.AreEqual(semanticVer, packageVersion.ToString());
}
public static string GetFullVersion(this AssemblyDefinition assembly, PackageVersion packageVersion)
{
if (!Enum.IsDefined(typeof(PackageVersion), packageVersion))
{
throw new InvalidEnumArgumentException(nameof(packageVersion), (int)packageVersion, typeof(PackageVersion));
}
if (packageVersion == PackageVersion.AssemblyVersionAttribute)
{
return(assembly.Name.Version.ToString());
}
return(assembly.CustomAttributes.GetFirstAttributeValueOrDefault(packageVersion.ToString(), assembly.Name.Version.ToString));
}
public void ToStringTest()
{
PackageVersion v;
String version;
//
// Prepare the test.
//
version = "1.3.7";
//
// Run the test.
//
v = new PackageVersion(version);
//
// Verify the test.
//
Assert.AreEqual(version, v.ToString());
}
/// <summary>
/// Fetch, if not already downloaded, and install the package represented by
/// (<paramref name="packageId"/>, <paramref name="version"/>).
/// </summary>
/// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks>
/// <param name="packageId">Name of package to install.</param>
/// <param name="version">Version of package to install.</param>
public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, IEnumerable <string> targetFrameworks, ProgressReport progress)
{
using (GetLocalRepositoryLock())
{
currentProgressReport = progress;
try
{
var identity = new PackageIdentity(packageId, version.ToNuGetVersion());
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
true,
true,
VersionConstraints.None);
var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray();
var projectContext = new EmptyNuGetProjectContext()
{
ActionType = NuGetActionType.Install,
PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.Skip, null, NativeLogger),
};
ActivityCorrelationId.StartNew();
{
var installPath = SettingsUtility.GetGlobalPackagesFolder(settings);
// In case it's a package without any TFM (i.e. Visual Studio plugin), we still need to specify one
if (!targetFrameworks.Any())
{
targetFrameworks = new string[] { "net6.0" }
}
;
// Old version expects to be installed in GamePackages
if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0) && oldRootDirectory != null)
{
installPath = oldRootDirectory;
}
var projectPath = Path.Combine("StrideLauncher.json");
var spec = new PackageSpec()
{
Name = Path.GetFileNameWithoutExtension(projectPath), // make sure this package never collides with a dependency
FilePath = projectPath,
Dependencies = new List <LibraryDependency>()
{
new LibraryDependency
{
LibraryRange = new LibraryRange(packageId, new VersionRange(version.ToNuGetVersion()), LibraryDependencyTarget.Package),
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.Combine(Path.GetTempPath(), $"StrideLauncher-{packageId}-{version.ToString()}"),
OriginalTargetFrameworks = targetFrameworks.ToList(),
ConfigFilePaths = settings.GetConfigFilePaths(),
PackagesPath = installPath,
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
};
foreach (var targetFramework in targetFrameworks)
{
spec.TargetFrameworks.Add(new TargetFrameworkInformation {
FrameworkName = NuGetFramework.Parse(targetFramework)
});
}
using (var context = new SourceCacheContext {
MaxAge = DateTimeOffset.UtcNow
})
{
context.IgnoreFailedSources = true;
var dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(spec);
dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
var restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = context,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)),
Log = NativeLogger,
};
// Create requests from the arguments
var requests = requestProvider.CreateRequests(restoreArgs).Result;
foreach (var request in requests)
{
// Limit concurrency to avoid timeout
request.Request.MaxDegreeOfConcurrency = 4;
var command = new RestoreCommand(request.Request);
// Act
var result = await command.ExecuteAsync();
if (!result.Success)
{
throw new InvalidOperationException($"Could not restore package {packageId}");
}
foreach (var install in result.RestoreGraphs.Last().Install)
{
var package = result.LockFile.Libraries.FirstOrDefault(x => x.Name == install.Library.Name && x.Version == install.Library.Version);
if (package != null)
{
var packagePath = Path.Combine(installPath, package.Path);
OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(install.Library.Name, install.Library.Version.ToPackageVersion()), packagePath));
}
}
}
}
if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0))
{
UpdateTargetsHelper();
}
}
// Load the recently installed package
var installedPackages = GetPackagesInstalled(new[] { packageId });
return(installedPackages.FirstOrDefault(p => p.Version == version));
}
finally
{
currentProgressReport = null;
}
}
}
public static NuGet.SemanticVersion ToSemanticVersion(this PackageVersion version)
{
return(version == null ? null : new NuGet.SemanticVersion(version.ToString()));
}
/// <summary>
/// User has entered a value in the version field. It has already been
/// validated and needs to be stored.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void tbVersion_Validated(object sender, EventArgs e)
{
Version = new PackageVersion(tbVersion.Text);
tbVersion.Text = Version.ToString();
}
public List <ICodebaseAlert> GenerateAlerts(Codebase codebase)
{
var alerts = new List <CodebaseAlert>();
foreach (var projectDirectory in codebase.ProjectDirectories)
{
Dictionary <string, List <ProjectDirectory> > qaOnlyPackages = new Dictionary <string, List <ProjectDirectory> >();
Dictionary <string, List <ProjectDirectory> > versionMismatchPackages = new Dictionary <string, List <ProjectDirectory> >();
Dictionary <string, string> packagesUsingProdVersion = new Dictionary <string, string>();
Dictionary <string, string> notFoundPackages = new Dictionary <string, string>();
if (projectDirectory.PackagesFile == null)
{
continue;
}
foreach (var packageReference in projectDirectory.PackagesFile.PackageReferences)
{
if (packageReference.PackageName == null)
{
continue;
}
var packageNameNormalised = packageReference.PackageName.Normalised();
var packageNameAndVersionNormalised = packageNameNormalised + "_" + packageReference.Version;
//Already checked as in prod - OK
if (packagesUsingProdVersion.ContainsKey(packageNameAndVersionNormalised))
{
continue;
}
if (notFoundPackages.ContainsKey(packageNameAndVersionNormalised))
{
continue;
}
//We are not the first project directory to use this QA package
List <ProjectDirectory> directoriesWithQaPackageAlready = new List <ProjectDirectory>();
if (qaOnlyPackages.TryGetValue(packageNameAndVersionNormalised, out directoriesWithQaPackageAlready))
{
directoriesWithQaPackageAlready.Add(projectDirectory);
continue;
}
//We are the first to check this package essentially
NuGetPackage latestInProd;
NuGetPackage latestInQa;
codebase.NuGetSourceProduction.LatestVersionLookup.TryGetValue(packageNameNormalised, out latestInProd);
codebase.NuGetSourceQa.LatestVersionLookup.TryGetValue(packageNameNormalised, out latestInQa);
//Not in either feed! Better log this
if (latestInProd == null && latestInQa == null)
{
notFoundPackages.Add(packageNameAndVersionNormalised, packageNameAndVersionNormalised);
continue;
}
//If it is in prod - add to that index
if (latestInProd != null && packageReference.Version <= latestInProd.Version)
{
if (!packagesUsingProdVersion.ContainsKey(packageNameAndVersionNormalised))
{
packagesUsingProdVersion.Add(packageNameAndVersionNormalised, packageNameAndVersionNormalised);
}
continue;
}
directoriesWithQaPackageAlready.Add(projectDirectory);
qaOnlyPackages.Add(packageNameAndVersionNormalised, directoriesWithQaPackageAlready);
}
foreach (var notFoundPackage in notFoundPackages.Keys.OrderBy(k => k))
{
var alert = new CodebaseAlert("Phantom NuGet Package Reference Alert", CodebaseAlertPriority.Critical, null)
.AddDetail("Package {0} is not found in either QA or Production Feeds", notFoundPackage);
alerts.Add(alert);
}
foreach (var qaOnlyPackage in qaOnlyPackages.Keys.OrderBy(k => k))
{
var alert = new CodebaseAlert("QA NuGet Package Reference Alert", CodebaseAlertPriority.Warning, null)
.AddDetail("Package {0} is currently only found in QA feed", qaOnlyPackage);
alerts.Add(alert);
}
foreach (var versionMismatchPackage in versionMismatchPackages.Keys.OrderBy(k => k))
{
PackageVersion expectedVersion = null;
var alert = new CodebaseAlert("NuGet Package Version Anomaly Alert", CodebaseAlertPriority.Critical, null)
.AddDetail("Package {0} is referenced instead of the standard version {1}", versionMismatchPackage, expectedVersion.ToString());
var affectedProjects = versionMismatchPackages[versionMismatchPackage];
foreach (var project in affectedProjects)
{
alert.AddDetail(" - {0}", project.DisplayPath(codebase.RootSourceDirectory));
}
alerts.Add(alert);
}
}
return(alerts.ToList <ICodebaseAlert>());
}
/// <summary>
/// Makes a string representation of the package name, version, and slot number.
/// </summary>
/// <param name="pkg">package name</param>
/// <param name="ver">package version</param>
/// <param name="slot">slot number</param>
/// <returns>formatted package version string</returns>
public static string FormatPackageVersion(string pkg, PackageVersion ver, uint slot)
{
StringBuilder sb = new StringBuilder();
sb.Append(pkg);
if (ver != null)
sb.Append(String.Format("-{0}", ver.ToString()));
if (slot > 0)
sb.Append(String.Format(":{0}", slot.ToString()));
return sb.ToString();
}
