public async ValueTask <IReadOnlyCollection <PackageDependencyInfo> > GetInstalledPackagesDependencyInfoAsync(
string projectId,
bool includeUnresolved,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectId);
cancellationToken.ThrowIfCancellationRequested();
NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken);
NuGetProject?project = await SolutionUtility.GetNuGetProjectAsync(
_sharedState.SolutionManager,
projectId,
cancellationToken);
Assumes.NotNull(project);
IEnumerable <PackageDependencyInfo>?results = await packageManager.GetInstalledPackagesDependencyInfo(
project,
cancellationToken,
includeUnresolved);
if (results == null)
{
return(Array.Empty <PackageDependencyInfo>());
}
return(results.ToArray());
}
private async Task <IReadOnlyList <SourceRepository> > GetGlobalPackageFolderRepositoriesAsync()
{
var settings = ServiceLocator.GetInstance <ISettings>();
NuGetPackageManager packageManager = await _sharedServiceState.PackageManager.GetValueAsync();
return(packageManager.GlobalPackageFolderRepositories);
}
private async Task ProcessPackagesConfigProjectsAsync(
IEnumerable <NuGetProject> projects,
NuGetPackageManager packageManager,
ISet <PackageIdentity> finishedPackages,
List <PackageItem> installedPackages,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
var packagesByFramework = new Dictionary <NuGetFramework, ISet <PackageIdentity> >();
foreach (var project in projects)
{
var result = await CollectPackagesForPackagesConfigAsync(project, token);
ISet <PackageIdentity> frameworkPackages;
if (!packagesByFramework.TryGetValue(result.Item1, out frameworkPackages))
{
frameworkPackages = new HashSet <PackageIdentity>();
packagesByFramework.Add(result.Item1, frameworkPackages);
}
frameworkPackages.UnionWith(result.Item2);
}
if (packagesByFramework.Count > 0)
{
await OrderPackagesForPackagesConfigAsync(
packageManager,
packagesByFramework,
finishedPackages,
installedPackages,
token);
}
}
private static async Task <IReadOnlyCollection <SourcePackageDependencyInfo> > GetAvailablePackageDependencies(
NuGetPackageManager packageManager,
NugetFolderProject nuGetProject,
PackageIdentity packageIdentity,
ResolutionContext resolutionContext,
INuGetProjectContext nuGetProjectContext,
ISet <SourceRepository> primarySources,
ISet <SourceRepository> allSources,
CancellationToken token)
{
var targetFramework = nuGetProject.GetMetadata <NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework);
var primaryPackages = new List <PackageIdentity> {
packageIdentity
};
var gatherContext = new GatherContext()
{
InstalledPackages = Array.Empty <PackageIdentity>(),
PrimaryTargets = primaryPackages,
TargetFramework = targetFramework,
PrimarySources = primarySources.ToList(),
AllSources = allSources.ToList(),
PackagesFolderSource = packageManager.PackagesFolderSourceRepository,
ResolutionContext = resolutionContext,
AllowDowngrades = false,
ProjectContext = nuGetProjectContext
};
return(await ResolverGather.GatherAsync(gatherContext, token));
}
/// <summary>Verifies that the plugin package and all of its dependencies exist locally</summary>
public virtual bool PackageAndDependenciesExist(NuGetPackageManager packageManager)
{
// Check this package
if (!packageManager.PackageExistsInPackagesFolder(Identity))
{
LogTo.Warning(
$"Cached plugin package {Id} {Version} does not exist in packages folder");
return(false);
}
// Check dependencies
foreach (var package in Dependencies)
{
if (!package.PackageExists(packageManager))
{
LogTo.Warning(
$"Cached package dependency {package.Id} {package.Version} "
+ $"of plugin {Id} {Version} does not exist in packages folder");
return(false);
}
}
return(true);
}
public static async Task UninstallPackage(string packageId, string version, ILogger logger = null)
{
if (logger == null)
{
logger = new ConsoleNuGetLogger();
}
PackageIdentity identity = new PackageIdentity(packageId, new NuGet.Versioning.NuGetVersion(version));
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
providers.AddRange(Repository.Provider.GetCoreV2()); // Add v2 API support
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(Platform.ReposDirectory, null, new MachineWideSettings(), false, true);
ISourceRepositoryProvider sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); // See part 2
using (var installedPackageCache = GetCache())
{
var project = new AvalonStudioExtensionsFolderProject(GetFramework(), installedPackageCache, Platform.ReposDirectory);
var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, new SolutionManager(), new DeleteOnRestartManager())
{
PackagesFolderNuGetProject = project,
};
INuGetProjectContext projectContext = new ProjectContext(logger);
var uninstallationContext = new UninstallationContext(true, true);
await packageManager.UninstallPackageAsync(project, packageId, uninstallationContext, projectContext, CancellationToken.None);
}
}
/// <summary>
/// Install package by Id
/// </summary>
/// <param name="project"></param>
/// <param name="packageId"></param>
/// <param name="resolutionContext"></param>
/// <param name="projectContext"></param>
/// <param name="isPreview"></param>
/// <param name="isForce"></param>
/// <param name="uninstallContext"></param>
/// <returns></returns>
protected async Task InstallPackageByIdAsync(NuGetProject project, string packageId, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview)
{
try
{
var actions = await PackageManager.PreviewInstallPackageAsync(project, packageId, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None);
if (isPreview)
{
PreviewNuGetPackageActions(actions);
}
else
{
var identity = actions.Select(v => v.PackageIdentity).Where(p => p.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
NuGetPackageManager.SetDirectInstall(identity, projectContext);
await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None);
NuGetPackageManager.ClearDirectInstall(projectContext);
}
}
catch (InvalidOperationException ex)
{
if (ex.InnerException is PackageAlreadyInstalledException)
{
Log(ProjectManagement.MessageLevel.Info, ex.Message);
}
else
{
throw ex;
}
}
}
public PackageRestoreContext(NuGetPackageManager nuGetPackageManager,
IEnumerable <PackageRestoreData> packages,
CancellationToken token,
EventHandler <PackageRestoredEventArgs> packageRestoredEvent,
EventHandler <PackageRestoreFailedEventArgs> packageRestoreFailedEvent,
IEnumerable <SourceRepository> sourceRepositories,
int maxNumberOfParallelTasks)
{
if (nuGetPackageManager == null)
{
throw new ArgumentNullException(nameof(nuGetPackageManager));
}
if (packages == null)
{
throw new ArgumentNullException(nameof(packages));
}
if (maxNumberOfParallelTasks <= 0)
{
throw new ArgumentException(Strings.ParameterCannotBeZeroOrNegative, nameof(maxNumberOfParallelTasks));
}
PackageManager = nuGetPackageManager;
Packages = packages;
Token = token;
PackageRestoredEvent = packageRestoredEvent;
PackageRestoreFailedEvent = packageRestoreFailedEvent;
SourceRepositories = sourceRepositories;
MaxNumberOfParallelTasks = maxNumberOfParallelTasks;
}
/// <summary>
/// Install package by Id
/// </summary>
/// <param name="project"></param>
/// <param name="packageId"></param>
/// <param name="resolutionContext"></param>
/// <param name="projectContext"></param>
/// <param name="isPreview"></param>
/// <param name="isForce"></param>
/// <param name="uninstallContext"></param>
/// <returns></returns>
protected async Task InstallPackageByIdAsync(NuGetProject project, string packageId, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview)
{
try
{
var actions = await PackageManager.PreviewInstallPackageAsync(project, packageId, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None);
if (!actions.Any())
{
// nuget operation status is set to NoOp to log under telemetry event when
// there is no preview action.
_status = NuGetOperationStatus.NoOp;
}
else
{
// update packages count to be logged under telemetry event
_packageCount = actions.Select(
action => action.PackageIdentity.Id).Distinct().Count();
}
// stop telemetry event timer to avoid UI interaction
TelemetryUtility.StopTimer();
if (!ShouldContinueDueToDotnetDeprecation(actions, isPreview))
{
// resume telemetry event timer after ui confirmation
TelemetryUtility.StartorResumeTimer();
return;
}
// resume telemetry event timer after ui confirmation
TelemetryUtility.StartorResumeTimer();
if (isPreview)
{
PreviewNuGetPackageActions(actions);
}
else
{
var identity = actions.Select(v => v.PackageIdentity).Where(p => p.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
NuGetPackageManager.SetDirectInstall(identity, projectContext);
await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None);
NuGetPackageManager.ClearDirectInstall(projectContext);
}
}
catch (InvalidOperationException ex)
{
if (ex.InnerException is PackageAlreadyInstalledException)
{
// Set nuget operation status to NoOp for telemetry event when package
// is already installed.
_status = NuGetOperationStatus.NoOp;
Log(MessageLevel.Info, ex.Message);
}
else
{
throw ex;
}
}
}
/// <summary>
/// Install package by Identity
/// </summary>
/// <param name="project"></param>
/// <param name="identity"></param>
/// <param name="resolutionContext"></param>
/// <param name="projectContext"></param>
/// <param name="isPreview"></param>
/// <param name="isForce"></param>
/// <param name="uninstallContext"></param>
/// <returns></returns>
protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview)
{
try
{
var actions = await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None);
if (isPreview)
{
PreviewNuGetPackageActions(actions);
}
else
{
NuGetPackageManager.SetDirectInstall(identity, projectContext);
await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None);
NuGetPackageManager.ClearDirectInstall(projectContext);
}
}
catch (InvalidOperationException ex)
{
if (ex.InnerException is PackageAlreadyInstalledException)
{
Log(ProjectManagement.MessageLevel.Info, ex.Message);
}
else
{
throw ex;
}
}
}
/// <summary>
/// Execute the installs/uninstalls
/// </summary>
private async Task ExecuteActionsAsync(
IEnumerable <ResolvedAction> actions,
INuGetProjectContext projectContext,
ICommonOperations commonOperations,
UserAction userAction,
SourceCacheContext sourceCacheContext,
CancellationToken token)
{
var nuGetProjects = actions.Select(action => action.Project);
var nuGetActions = actions.Select(action => action.Action);
var directInstall = GetDirectInstall(nuGetActions, userAction, commonOperations);
if (directInstall != null)
{
NuGetPackageManager.SetDirectInstall(directInstall, projectContext);
}
await _packageManager.ExecuteNuGetProjectActionsAsync(
nuGetProjects,
nuGetActions,
projectContext,
sourceCacheContext,
token);
NuGetPackageManager.ClearDirectInstall(projectContext);
}
public PluginAssemblyStore(
ILogger <PluginAssemblyStore> logger,
NuGetPackageManager nuGetPackageManager)
{
m_Logger = logger;
m_NuGetPackageManager = nuGetPackageManager;
}
private async Task ExecuteInitPs1ForPackagesConfig(
NuGetPackageManager packageManager,
Dictionary <NuGetFramework, HashSet <PackageIdentity> > packagesConfigInstalled,
HashSet <PackageIdentity> finishedPackages)
{
// Get the path to the Packages folder.
var packagesFolderPath = packageManager.PackagesFolderSourceRepository.PackageSource.Source;
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var packagesToSort = new HashSet <ResolverPackage>();
var resolvedPackages = new HashSet <PackageIdentity>();
var dependencyInfoResource = await packageManager
.PackagesFolderSourceRepository
.GetResourceAsync <DependencyInfoResource>();
// Order by the highest framework first to make this deterministic
// Process each framework/id/version once to avoid duplicate work
// Packages may have different dependendcy orders depending on the framework, but there is
// no way to fully solve this across an entire solution so we make a best effort here.
foreach (var framework in packagesConfigInstalled.Keys.OrderByDescending(fw => fw, new NuGetFrameworkSorter()))
{
foreach (var package in packagesConfigInstalled[framework])
{
if (resolvedPackages.Add(package))
{
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package,
framework,
NullLogger.Instance,
CancellationToken.None);
// This will be null for unrestored packages
if (dependencyInfo != null)
{
packagesToSort.Add(new ResolverPackage(dependencyInfo, listed: true, absent: false));
}
}
}
}
// Order packages by dependency order
var sortedPackages = ResolverUtility.TopologicalSort(packagesToSort);
foreach (var package in sortedPackages)
{
if (finishedPackages.Add(package))
{
// Find the package path in the packages folder.
var installPath = packagePathResolver.GetInstalledPath(package);
if (string.IsNullOrEmpty(installPath))
{
continue;
}
ExecuteInitPs1(installPath, package);
}
}
}
private async Task <IEnumerable <NuGetProjectAction> > PacManCleanInstall(SourceRepositoryProvider sourceRepositoryProvider, PackageIdentity target)
{
// Arrange
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomPackagesConfigFolderPath = TestDirectory.Create())
{
var testSettings = new Configuration.NullSettings();
var token = CancellationToken.None;
var deleteOnRestartManger = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManger);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath);
// Act
var nugetProjectActions = await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, target,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
return(nugetProjectActions);
}
}
public async Task Do(string package, string rootPath)
{
if (rootPath == null)
{
rootPath = Directory.GetCurrentDirectory();
}
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
var settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings());
var project = new ProjectBazel(rootPath, null);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers);
var solutionManager = new BazelSolutionManager(project, rootPath);
var deleteManager = new DeleteOnRestart();
var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, solutionManager, deleteManager)
{
PackagesFolderNuGetProject = project,
};
var projectContext = new ProjectContext();
var uninstallContext = new UninstallationContext(true, true);
await packageManager.UninstallPackageAsync(packageManager.PackagesFolderNuGetProject,
package, uninstallContext, projectContext,
CancellationToken.None);
}
/// <summary>
/// Downloads and extracts the specified dependency to the NuGet package folder.
/// </summary>
/// <param name="dependency">Dependency indicating the specific Id and Version of the package to download.</param>
public async Task DownloadPackageAsync(Dependency dependency)
{
// Use V3 providers to get an instance of the NuGetPackageManager. We'll use
// defaults for everything as we are doing a simple package download to a folder.
var identity = dependency.ToPackageIdentity();
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(Settings.NugetPackageDirectory);
var cores = Repository.Provider.GetPageableCoreV3().Select(p => new Lazy <INuGetResourceProvider>(() => p));
var provider = new SourceRepositoryProvider(settings, cores);
var packageManager = new NuGetPackageManager(provider, settings, Settings.NugetPackageDirectory)
{
PackagesFolderNuGetProject = _packageFolder
};
// When the package already exists in the package folder, there is nothing to do.
if (packageManager.PackageExistsInPackagesFolder(identity))
{
return;
}
// We'll create an instance of ResolutionContext using the standard resolution behavior.
var resolutionContext = new ResolutionContext(NuGet.Resolver.DependencyBehavior.Lowest, true, true, VersionConstraints.None);
var projectContext = new NuGetProjectContext();
var sourceRepositories = provider.GetRepositories();
// Use the package manager to download an install the specified dependencies.
await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
identity, resolutionContext, projectContext, sourceRepositories,
Array.Empty <SourceRepository>(),
CancellationToken.None);
}
/// <summary>
/// Execute the installs/uninstalls
/// </summary>
private async Task ExecuteActionsAsync(
IEnumerable <ResolvedAction> actions,
INuGetProjectContext projectContext,
ICommonOperations commonOperations,
UserAction userAction,
SourceCacheContext sourceCacheContext,
CancellationToken token)
{
var processedDirectInstalls = new HashSet <PackageIdentity>(PackageIdentity.Comparer);
foreach (var projectActions in actions.GroupBy(e => e.Project))
{
var nuGetProjectActions = projectActions.Select(e => e.Action);
var directInstall = GetDirectInstall(nuGetProjectActions, userAction, commonOperations);
if (directInstall != null &&
!processedDirectInstalls.Contains(directInstall))
{
NuGetPackageManager.SetDirectInstall(directInstall, projectContext);
processedDirectInstalls.Add(directInstall);
}
await _packageManager.ExecuteNuGetProjectActionsAsync(projectActions.Key, nuGetProjectActions, projectContext, sourceCacheContext, token);
NuGetPackageManager.ClearDirectInstall(projectContext);
}
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId"));
}
PumpingJTF.Run(async delegate
{
NuGetPackageManager packageManager =
new NuGetPackageManager(
_sourceRepositoryProvider,
_settings,
_solutionManager,
_deleteOnRestartManager);
UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false);
VSAPIProjectContext projectContext = new VSAPIProjectContext();
// find the project
NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext);
// uninstall the package
await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None);
});
}
public NuGetDownloader(TargetFramework targetFramework, string?outputDir = null,
bool includePrerelease = false, bool recursive = false, bool extract = true,
IEnumerable <string>?sources = null)
: base(sources)
{
TargetFramework = targetFramework;
Recursive = recursive;
Extract = extract;
IncludePrerelease = includePrerelease;
outputDir ??= Directory.GetCurrentDirectory();
(_downloadDir, _extractDir) = extract
? (Path.Combine(Path.GetTempPath(), $"NuGetPackageDownloader.{Guid.NewGuid():N}"), outputDir)
: (outputDir, null);
_framework = targetFramework.ToNuGetFramework();
_project = new FolderNuGetProject(_downloadDir);
var packageSourceProvider = new PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
_packageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, _downloadDir)
{
PackagesFolderNuGetProject = _project,
};
}
public async ValueTask UninstallPackagesAsync(
string projectId,
IReadOnlyList <PackageIdentity> packageIdentities,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectId);
Assumes.NotNullOrEmpty(packageIdentities);
cancellationToken.ThrowIfCancellationRequested();
MSBuildNuGetProject project = await GetMsBuildNuGetProjectAsync(projectId, cancellationToken);
IEnumerable <NuGetProjectAction>?actions = packageIdentities
.Select(packageIdentity => NuGetProjectAction.CreateUninstallProjectAction(packageIdentity, project));
NuGetPackageManager packageManager = await _state.GetPackageManagerAsync(cancellationToken);
Assumes.NotNull(packageManager);
INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>();
Assumes.NotNull(projectContext);
await packageManager.ExecuteNuGetProjectActionsAsync(
project,
actions,
projectContext,
NullSourceCacheContext.Instance,
CancellationToken.None);
}
/// <summary>
/// Core install method. All installs from the VS API and template wizard end up here.
/// This does not check for already installed packages
/// </summary>
internal async Task InstallInternalCoreAsync(
NuGetPackageManager packageManager,
GatherCache gatherCache,
NuGetProject nuGetProject,
PackageIdentity package,
IEnumerable <SourceRepository> sources,
VSAPIProjectContext projectContext,
bool includePrerelease,
bool ignoreDependencies,
CancellationToken token)
{
await TaskScheduler.Default;
DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
ResolutionContext resolution = new ResolutionContext(
depBehavior,
includePrerelease,
includeUnlisted: false,
versionConstraints: VersionConstraints.None,
gatherCache: gatherCache);
// install the package
if (package.Version == null)
{
await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token);
}
else
{
await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token);
}
}
private void InstallPackages(NuGetPackageManager packageManager, IReadOnlyList <SourceRepository> installationRepositories)
{
foreach (Package package in _packages.Values)
{
package.Install(installationRepositories, packageManager).Wait();
}
}
internal void InstallPackages()
{
DirectoryPath packagesPath = GetAbsolutePackagesPath();
Trace.Information($"Installing packages to {packagesPath.FullPath} (using {(UseLocalPackagesFolder ? "local" : "global")} packages folder)");
try
{
// Add the global default sources if requested
if (UseGlobalPackageSources)
{
_sourceRepositories.AddGlobalDefaults();
}
// Get the local repository
SourceRepository localRepository = _sourceRepositories.CreateRepository(packagesPath.FullPath);
// Get the package manager and repositories
WyamFolderNuGetProject nuGetProject = new WyamFolderNuGetProject(_fileSystem, _assemblyLoader, _currentFramework, packagesPath.FullPath);
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositories, _settings, packagesPath.FullPath)
{
PackagesFolderNuGetProject = nuGetProject
};
IReadOnlyList <SourceRepository> remoteRepositories = _sourceRepositories.GetDefaultRepositories();
// Resolve all the versions
IReadOnlyList <SourceRepository> installationRepositories = remoteRepositories;
try
{
ResolveVersions(localRepository, remoteRepositories);
}
catch (Exception ex)
{
Trace.Verbose($"Exception while resolving package versions: {ex.Message}");
Trace.Warning("Error while resolving package versions, attempting without remote repositories");
installationRepositories = new[] { localRepository };
ResolveVersions(localRepository, Array.Empty <SourceRepository>());
}
// Install the packages (doing this synchronously since doing it in parallel triggers file lock errors in NuGet on a clean system)
try
{
InstallPackages(packageManager, installationRepositories);
}
catch (Exception ex)
{
Trace.Verbose($"Exception while installing packages: {(ex is AggregateException ? string.Join("; ", ((AggregateException)ex).InnerExceptions.Select(x => x.Message)) : ex.Message)}");
Trace.Warning("Error while installing packages, attempting without remote repositories");
InstallPackages(packageManager, new[] { localRepository });
}
// Process the package (do this after all packages have been installed)
nuGetProject.ProcessAssembliesAndContent();
}
catch (Exception ex)
{
Trace.Verbose($"Unexpected exception while installing packages: {(ex is AggregateException ? string.Join("; ", ((AggregateException)ex).InnerExceptions.Select(x => x.Message)) : ex.Message)}");
Trace.Warning("Error while installing packages, attempting to continue anyway");
}
}
/// <summary>
/// Installs application package.
/// </summary>
/// <remarks>
/// На текущий момент это вся документация по использованию библиотек Nuget:
/// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-1
/// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-2
/// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-3
/// </remarks>
/// <returns></returns>
public async Task Install(AppInfo appInfo)
{
var sourceRepository = new SourceRepository(_nugetSettings.PackageSource.Value, _nugetSettings.ResourceProviders);
var sourceRepositoryProvider = new SourceRepositoryProvider(_nugetSettings.Configuration.Value, _nugetSettings.ResourceProviders);
var project = new FolderNuGetProject(_appSettings.InstallDirectoryPath);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, _nugetSettings.Configuration.Value, PackagesFolderPath)
{
PackagesFolderNuGetProject = project
};
var resolutionContext = new ResolutionContext(DependencyBehavior.Lowest, true, false, VersionConstraints.None);
var emptyNuGetProjectContext = new EmptyNuGetProjectContext();
var sourceRepositories = Array.Empty <SourceRepository>();
await nuGetPackageManager.InstallPackageAsync(project, new PackageIdentity(appInfo.PackageId, NuGetVersion.Parse(appInfo.Version)), resolutionContext, emptyNuGetProjectContext, sourceRepository, sourceRepositories, CancellationToken.None);
if (appInfo.HasInstance())
{
var directoryName = Path.Combine(_appSettings.InstallDirectoryPath, $"{appInfo.PackageId}.{appInfo.Version}");
var directoryForInstanceName = Path.Combine(_appSettings.InstallDirectoryPath, appInfo.ToString());
var directoryInfo = new DirectoryInfo(directoryName);
if (directoryInfo.Exists && !Directory.Exists(directoryForInstanceName))
{
directoryInfo.MoveTo(directoryForInstanceName);
}
}
}
private async Task <object> InitializeRuntimeAsync(NuGetPackageManager packageManager, List <Assembly> hostAssemblies, string workingDirectory, string[] commandlineArgs)
{
var runtimeAssembly = FindAssemblyInCurrentDomain("OpenMod.Runtime");
var apiAssembly = FindAssemblyInCurrentDomain("OpenMod.API");
var runtimeType = runtimeAssembly.GetType("OpenMod.Runtime.Runtime");
if (runtimeType == null)
{
throw new Exception($"Failed to find Runtime class in: {runtimeAssembly}");
}
var runtime = Activator.CreateInstance(runtimeType);
var parametersType = apiAssembly.GetType("OpenMod.API.RuntimeInitParameters");
var parameters = Activator.CreateInstance(parametersType);
SetParameter(parameters, "WorkingDirectory", workingDirectory);
SetParameter(parameters, "CommandlineArgs", commandlineArgs);
SetParameter(parameters, "PackageManager", packageManager);
var initMethod = runtimeType.GetMethod("InitAsync", BindingFlags.Instance | BindingFlags.Public);
if (initMethod == null)
{
throw new Exception($"Failed to find InitAsync in: {runtimeType.FullName}");
}
await(Task) initMethod.Invoke(runtime, new[] { hostAssemblies, parameters, null /* hostBuilderFunc */ });
return(runtime);
}
// Non-private only to facilitate testing.
internal NuGetUIContext(
ISourceRepositoryProvider sourceProvider,
IServiceBroker serviceBroker,
IVsSolutionManager solutionManager,
NuGetSolutionManagerServiceWrapper solutionManagerService,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IEnumerable <IVsPackageManagerProvider> packageManagerProviders)
{
SourceProvider = sourceProvider;
ServiceBroker = serviceBroker;
SolutionManager = solutionManager;
_solutionManagerService = solutionManagerService;
PackageManager = packageManager;
UIActionEngine = uiActionEngine;
PackageManager = packageManager;
PackageRestoreManager = packageRestoreManager;
OptionsPageActivator = optionsPageActivator;
UserSettingsManager = userSettingsManager;
PackageManagerProviders = packageManagerProviders;
ServiceBroker.AvailabilityChanged += OnAvailabilityChanged;
SolutionManager.ActionsExecuted += OnActionsExecuted;
}
private static async Task <string> GetLatestPackageVersionAsync(string packageId, CancellationToken cancellationToken = default)
{
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
// We SHOULD use all the sources from the target's nuget.config file.
// But I don't know what API to use to do that.
var packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
var sourceRepository = new SourceRepository(packageSource, providers);
var resolutionContext = new ResolutionContext(
DependencyBehavior.Highest,
includePrelease: false,
includeUnlisted: false,
VersionConstraints.None);
// The target framework doesn't matter, since our package doesn't depend on this for its target projects.
var framework = new NuGet.Frameworks.NuGetFramework("net45");
var pkg = await NuGetPackageManager.GetLatestVersionAsync(
packageId,
framework,
resolutionContext,
sourceRepository,
NullLogger.Instance,
cancellationToken);
return(pkg.LatestVersion.ToNormalizedString());
}
static async Task Main(string[] args)
{
var logger = new CompositeLogger();
var parsedOptions = Parser.Default.ParseArguments <DeleteOptions>(args);
await parsedOptions.MapResult(async options =>
{
using HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("X-NuGet-ApiKey", options.ApiKey);
using NuGetPackageManager pkgManager = new NuGetPackageManager(client, logger);
foreach (var package in options.PackageNames.Where(p => !string.IsNullOrWhiteSpace(p)))
{
var versions = await pkgManager.GetPackageVersionsAsync(package, CancellationToken.None);
foreach (var version in versions)
{
if (options.Force)
{
await pkgManager.DeletePackageAsync(version.Item1, version.Item2, CancellationToken.None);
}
else
{
logger.LogInformation($"Package {package} version {version} will be removed");
}
}
}
},
errors =>
{
HandleErrors(errors, logger);
return(Task.FromResult(0));
});
}
/// <summary>
/// Get the list of packages to be reinstalled given the project framework and packageReferences
/// </summary>
/// <param name="projectFramework">Current target framework of the project</param>
/// <param name="packageReferences">List of package references in the project from which packages to be reinstalled are determined</param>
/// <returns>List of package identities to be reinstalled</returns>
public static List <PackageIdentity> GetPackagesToBeReinstalled(NuGetFramework projectFramework, IEnumerable <Packaging.PackageReference> packageReferences)
{
Debug.Assert(projectFramework != null);
Debug.Assert(packageReferences != null);
var packagesToBeReinstalled = new List <PackageIdentity>();
var sourceRepositoryProvider = ServiceLocator.GetInstance <ISourceRepositoryProvider>();
var solutionManager = ServiceLocator.GetInstance <ISolutionManager>();
var settings = ServiceLocator.GetInstance <Configuration.ISettings>();
var deleteOnRestartManager = ServiceLocator.GetInstance <IDeleteOnRestartManager>();
var packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager);
foreach (var packageReference in packageReferences)
{
var identity = packageReference.PackageIdentity;
if (identity != null && ShouldPackageBeReinstalled(projectFramework, packageReference.TargetFramework, identity, packageManager))
{
packagesToBeReinstalled.Add(identity);
}
}
return(packagesToBeReinstalled);
}
private void InstallPackages(NuGetPackageManager packageManager, IReadOnlyList <SourceRepository> installationRepositories, InstalledPackagesCache installedPackages)
{
foreach (Package package in _packages.Values)
{
package.Install(installationRepositories, installedPackages, packageManager, _settings).GetAwaiter().GetResult();
}
}
public NuGetUIContextBase(
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGetProject> projects)
{
_sourceProvider = sourceProvider;
_solutionManager = solutionManager;
_packageManager = packageManager;
_uiActionEngine = uiActionEngine;
_packageManager = packageManager;
_packageRestoreManager = packageRestoreManager;
_optionsPageActivator = optionsPageActivator;
_projects = projects.ToArray();
}
public PackageLoader(PackageLoaderOption option,
NuGetPackageManager packageManager,
IEnumerable<NuGetProject> projects,
SourceRepository sourceRepository,
string searchText)
{
_sourceRepository = sourceRepository;
_packageManager = packageManager;
_projects = projects.ToArray();
_option = option;
_searchText = searchText;
LoadingMessage = string.IsNullOrWhiteSpace(searchText) ?
Resources.Text_Loading :
string.Format(
CultureInfo.CurrentCulture,
Resources.Text_Searching,
searchText);
_installedPackages = new HashSet<PackageIdentity>(PackageIdentity.Comparer);
_installedPackageIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Create a UIActionEngine to perform installs/uninstalls
/// </summary>
public UIActionEngine(ISourceRepositoryProvider sourceProvider, NuGetPackageManager packageManager)
{
_sourceProvider = sourceProvider;
_packageManager = packageManager;
}
