/// <summary>
/// This is the runner which dequeues package references from <paramref name="packageReferencesQueue" />, and
/// performs copying of satellite files
/// Note that this method should only Dequeue from the concurrent queue and not Enqueue
/// </summary>
private static async Task CopySatelliteFilesRunnerAsync(ConcurrentQueue <Packaging.PackageReference> packageReferencesQueue,
PackageRestoreContext packageRestoreContext,
INuGetProjectContext nuGetProjectContext)
{
Packaging.PackageReference currentPackageReference = null;
while (packageReferencesQueue.TryDequeue(out currentPackageReference))
{
var result = await packageRestoreContext.PackageManager.CopySatelliteFilesAsync(currentPackageReference.PackageIdentity, nuGetProjectContext, packageRestoreContext.Token);
}
}
/// <summary>
/// This is the runner which dequeues package references from <paramref name="packageReferencesQueue" />, and
/// performs package restore
/// Note that this method should only Dequeue from the concurrent queue and not Enqueue
/// </summary>
private static async Task <bool> PackageRestoreRunnerAsync(ConcurrentQueue <Packaging.PackageReference> packageReferencesQueue,
PackageRestoreContext packageRestoreContext,
INuGetProjectContext nuGetProjectContext)
{
Packaging.PackageReference currentPackageReference = null;
var restoreResult = true;
while (packageReferencesQueue.TryDequeue(out currentPackageReference))
{
var result = await RestorePackageAsync(currentPackageReference, packageRestoreContext, nuGetProjectContext);
restoreResult &= result;
}
return(restoreResult);
}
public PackageRestoreData(Packaging.PackageReference packageReference, IEnumerable <string> projectNames, bool isMissing)
{
if (packageReference == null)
{
throw new ArgumentNullException(nameof(packageReference));
}
if (projectNames == null)
{
throw new ArgumentNullException(nameof(projectNames));
}
PackageReference = packageReference;
ProjectNames = projectNames;
IsMissing = isMissing;
}
/// <summary>
/// Marks the packages to be reinstalled on the projects' packages.config
/// </summary>
public static async Task MarkPackagesForReinstallation(NuGetProject project, IList <PackageIdentity> packagesToBeReinstalled)
{
Debug.Assert(project != null);
Debug.Assert(packagesToBeReinstalled != null);
var installedPackageReferences = (await project.GetInstalledPackagesAsync(CancellationToken.None)).ToList();
var packageReferencesToUpdateReinstall = new Dictionary <Packaging.PackageReference, Packaging.PackageReference>();
if (installedPackageReferences != null && installedPackageReferences.Any())
{
foreach (var packageReference in installedPackageReferences)
{
bool markForReinstall = packagesToBeReinstalled.Any(p => p.Equals(packageReference.PackageIdentity));
// Determine if requireReinstallation attribute needs to be updated.
if (packageReference.RequireReinstallation ^ markForReinstall)
{
var newPackageReference = new Packaging.PackageReference(packageReference.PackageIdentity, packageReference.TargetFramework,
packageReference.IsUserInstalled, packageReference.IsDevelopmentDependency, markForReinstall);
packageReferencesToUpdateReinstall.Add(packageReference, newPackageReference);
}
}
var projectFullPath = project.GetMetadata <string>(NuGetProjectMetadataKeys.FullPath);
var packagesConfigFullPath = Path.Combine(projectFullPath ?? string.Empty, ProjectManagement.Constants.PackageReferenceFile);
// Create new file or overwrite existing file
if (File.Exists(packagesConfigFullPath))
{
try
{
using (var writer = new PackagesConfigWriter(packagesConfigFullPath, createNew: false))
{
foreach (var entry in packageReferencesToUpdateReinstall)
{
writer.UpdatePackageEntry(entry.Key, entry.Value);
}
}
}
catch (Exception ex)
{
ExceptionHelper.WriteErrorToActivityLog(ex);
}
}
}
}
private static async Task <bool> RestorePackageAsync(Packaging.PackageReference packageReference,
PackageRestoreContext packageRestoreContext,
INuGetProjectContext nuGetProjectContext)
{
Exception exception = null;
var restored = false;
try
{
restored = await packageRestoreContext.PackageManager.RestorePackageAsync(packageReference.PackageIdentity, nuGetProjectContext,
packageRestoreContext.SourceRepositories, packageRestoreContext.Token);
}
catch (Exception ex)
{
exception = ex;
}
if (packageRestoreContext.PackageRestoredEvent != null)
{
packageRestoreContext.PackageRestoredEvent(null, new PackageRestoredEventArgs(packageReference.PackageIdentity, restored));
}
// PackageReferences cannot be null here
if (exception != null)
{
nuGetProjectContext.Log(ProjectManagement.MessageLevel.Warning, exception.Message);
if (packageRestoreContext.PackageRestoreFailedEvent != null)
{
var packageReferenceComparer = new PackageReferenceComparer();
var packageRestoreData = packageRestoreContext.Packages
.Where(p => packageReferenceComparer.Equals(p.PackageReference, packageReference))
.SingleOrDefault();
if (packageRestoreData != null)
{
Debug.Assert(packageRestoreData.ProjectNames != null);
packageRestoreContext.PackageRestoreFailedEvent(null, new PackageRestoreFailedEventArgs(packageReference,
exception,
packageRestoreData.ProjectNames));
}
}
}
return(restored);
}
public PackageRestoreFailedEventArgs(Packaging.PackageReference restoredFailedPackageReference, Exception exception, IEnumerable <string> projectNames)
{
if (restoredFailedPackageReference == null)
{
throw new ArgumentNullException(nameof(restoredFailedPackageReference));
}
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
if (projectNames == null)
{
throw new ArgumentNullException(nameof(projectNames));
}
RestoreFailedPackageReference = restoredFailedPackageReference;
Exception = exception;
ProjectNames = projectNames;
}
// TODO: Consider removing elements from the collection and check if that is better in performance
public static IEnumerable <SourcePackageDependencyInfo> RemoveDisallowedVersions(IEnumerable <SourcePackageDependencyInfo> packages, Packaging.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);
}
