public async override Task ExecuteCommand()
{
CalculateEffectivePackageSaveMode();
string installPath = ResolveInstallPath();
var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
IEnumerable<SourceRepository> primarySources;
IEnumerable<SourceRepository> secondarySources;
GetEffectiveSources(sourceRepositoryProvider, out primarySources, out secondarySources);
if(Arguments.Count == 0)
{
throw new InvalidOperationException(NuGetResources.InstallCommandPackageIdMustBeProvided);
}
string packageId = Arguments[0];
NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, installPath);
ResolutionContext resolutionContext = new ResolutionContext(dependencyBehavior: DependencyBehavior, includePrelease: Prerelease);
FolderNuGetProject nugetProject = new FolderNuGetProject(installPath);
nugetProject.PackageSaveMode = EffectivePackageSaveMode;
if (Version == null)
{
await packageManager.InstallPackageAsync(nugetProject, packageId, resolutionContext, new Common.Console(),
primarySources, secondarySources, CancellationToken.None);
}
else
{
await packageManager.InstallPackageAsync(nugetProject, new PackageIdentity(packageId, new NuGetVersion(Version)), resolutionContext,
new Common.Console(), primarySources, secondarySources, CancellationToken.None);
}
}
public async Task <IEnumerable <IPackageSearchMetadata> > Find(string name, string version)
{
var settings = NullSettings.Instance;
var packageSourceProvider = new PackageSourceProvider(
settings,
new PackageSource[] { new PackageSource("https://www.powershellgallery.com/api/v2/") }
);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
IEnumerable <IPackageSearchMetadata> results = new List <IPackageSearchMetadata>();
var searchFilter = new SearchFilter(true, SearchFilterType.IsAbsoluteLatestVersion);
foreach (var repo in repositories)
{
var resource = await repo.GetResourceAsync <PackageSearchResource>();
var info = await resource.SearchAsync(name, searchFilter, 0, 200, NullLogger.Instance, CancellationToken.None);
results = results.Concat(info);
}
return(results);
}
}
private CompositionContainer Initialize()
{
var assemblyName = Assembly.GetEntryAssembly().FullName;
var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var catalog = new AggregateCatalog(
new AssemblyCatalog(Assembly.Load(assemblyName)),
new DirectoryCatalog(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NuGet*.dll"));
var container = new CompositionContainer(catalog);
var settings = Settings.LoadDefaultSettings(null, null, null);
container.ComposeExportedValue(settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetVisualStudio());
container.ComposeExportedValue <ISourceRepositoryProvider>(sourceRepositoryProvider);
var testSolutionManager = new TestSolutionManager(@"c:\temp\test");
var projectA = testSolutionManager.AddNewMSBuildProject("projectA");
container.ComposeExportedValue <ISolutionManager>(testSolutionManager);
var sourceControlManager = new TestSourceControlManager();
var sourceControlManagerProvider = new TestSourceControlManagerProvider(sourceControlManager);
container.ComposeExportedValue <ISourceControlManagerProvider>(sourceControlManagerProvider);
container.ComposeParts(this);
return(container);
}
//determines all command package dependencies and downloads their .nupkg files to Program Files
public static async Task DownloadCommandDependencyPackages()
{
string programPackagesSource = Folders.GetFolder(FolderType.ProgramFilesPackagesFolder);
List <string> newPackageFilePaths = MovePackagesToProgramFiles();
string nugetSourcePath = "https://api.nuget.org/v3/index.json";
string gallerySourcePath = "https://gallery.openbots.io/v3/command.json";
List <string> packageList = new List <string>();
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var repositories = new List <SourceRepository>();
var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(programPackagesSource, "Program Files", true));
var nugetRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(nugetSourcePath, "Nuget", true));
var galleryRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(gallerySourcePath, "Gallery", true));
repositories.Add(sourceRepo);
repositories.Add(nugetRepo);
repositories.Add(galleryRepo);
try
{
foreach (string packagePath in newPackageFilePaths)
{
var matches = Regex.Matches(packagePath, @"(\w+\.\w+\.*\w*)\.(\d+\.\d+\.\d+)");
string packageId = matches[0].Groups[1].Value;
string version = matches[0].Groups[2].Value;
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
var dependencyTasks = repositories.Select(repository => GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repository, repositories, availablePackages)).ToList();
await Task.WhenAll(dependencyTasks);
foreach (var package in availablePackages)
{
packageList.Add($"{package.Id}*{package.Version}");
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
List <string> filteredPackageList = packageList.Distinct().ToList();
foreach (var package in filteredPackageList)
{
await DownloadPackage(package.Split('*')[0], package.Split('*')[1], programPackagesSource, $"{package.Split('*')[0]}.{package.Split('*')[1]}", repositories);
}
}
public static async Task <ISet <PackageIdentity> > GetAllDependenciesAsync(string packageId,
string version)
{
var package = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var settings = Settings.LoadDefaultSettings(null);
var nuGetFramework = NuGetFramework.AnyFramework;
var logger = NullLogger.Instance;
var cancelToken = CancellationToken.None;
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var availablePackages = new HashSet <PackageIdentity>(PackageIdentityComparer.Default);
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
await GetDependenciesAsync(package,
nuGetFramework,
cacheContext,
logger,
repositories,
availablePackages,
cancelToken);
}
return(availablePackages);
}
public async override Task ExecuteCommand()
{
IEnumerable<SourceRepository> sourceRepository;
if (Source.Any())
{
List<SourceRepository> sourceList = new List<SourceRepository>();
foreach (var source in Source)
{
sourceList.Add(new SourceRepository(new PackageSource(source), ResourceProviders));
}
sourceRepository = sourceList;
}
else
{
var packageSourceProvider = new PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
sourceRepository = sourceRepositoryProvider.GetRepositories();
}
var selfUpdater = new SelfUpdater(sourceRepository.FirstOrDefault())
{
Console = Console
};
await selfUpdater.UpdateSelf();
}
public NuGetPluginSolution(DirectoryPath pluginDirPath,
DirectoryPath pluginHomeDirPath,
DirectoryPath packageDirPath,
NuGetInstalledPluginRepository <TMeta> pluginRepo,
SourceRepositoryProvider sourceRepositories,
ISettings settings,
NuGetFramework currentFramework)
{
SolutionDirectory = pluginDirPath.Collapse().FullPath;
NuGetProjectContext = new NuGetProjectContext(settings);
_packageDirPath = packageDirPath;
_pluginHomeDirPath = pluginHomeDirPath;
_pluginRepo = pluginRepo;
_sourceRepositories = sourceRepositories;
_settings = settings;
_currentFramework = currentFramework;
_projectMap = _pluginRepo.Plugins.Select(
p => new NuGetPluginProject <TMeta>(
CreatePackageManager,
_currentFramework,
_packageDirPath,
_pluginHomeDirPath,
p,
true)
).ToDictionary(k => k.Plugin.Id);
}
public async Task GetPackageDependencies(PackageIdentity package, SourceCacheContext cacheContext, ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
var repositories = SourceRepositoryProvider.GetRepositories();
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, NuGetFramework, cacheContext, Logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
foreach (var dependency in dependencyInfo.Dependencies)
{
var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion);
await GetPackage(identity);
await GetPackageDependencies(identity, cacheContext, availablePackages);
}
}
}
private async Task <Uri> GetNugetUri(CancellationToken cancellationToken)
{
var settings = Settings.LoadDefaultSettings(null);
var packageSourceProvider = new PackageSourceProvider(settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, FactoryExtensionsV3.GetCoreV3(Repository.Provider));
var package = new PackageIdentity("PostgreSql.Binaries.Lite", NuGetVersion.Parse(_pgVersion));
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, NuGetFramework.AnyFramework, cacheContext, NullLogger.Instance, cancellationToken);
if (dependencyInfo != null)
{
return(dependencyInfo.DownloadUri);
}
}
}
throw new Exception("Could not find PostgreSql.Binaries.Lite package");
}
public NuGetClient()
{
_nuGetFramework = NuGetFramework.ParseFolder("netstandard20");
_settings = Settings.LoadDefaultSettings(root: null);
_packageSourceProvider = new PackageSourceProvider(_settings);
_sourceRepositoryProvider = new SourceRepositoryProvider(_packageSourceProvider, Repository.Provider.GetCoreV3());
}
private async Task <Uri> GetNugetUri(CancellationToken cancellationToken)
{
var settings = Settings.LoadDefaultSettings(null);
var packageSourceProvider = new PackageSourceProvider(settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, FactoryExtensionsV3.GetCoreV3(Repository.Provider));
var package = new PackageIdentity("PostgreSql.Binaries.Lite", NuGetVersion.Parse(_pgVersion));
var pathContext = NuGetPathContext.Create(settings);
var localSources = new List <string>();
localSources.Add(pathContext.UserPackageFolder);
localSources.AddRange(pathContext.FallbackPackageFolders);
using (var cacheContext = new SourceCacheContext())
{
var repositories = localSources
.Select(path => sourceRepositoryProvider.CreateRepository(new PackageSource(path), FeedType.FileSystemV3))
.Concat(sourceRepositoryProvider.GetRepositories());
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, NuGetFramework.AnyFramework, cacheContext, NullLogger.Instance, cancellationToken);
if (dependencyInfo != null)
{
return(dependencyInfo.DownloadUri);
}
}
}
throw new Exception("Could not find PostgreSql.Binaries.Lite package");
}
/// <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);
}
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,
};
}
private List <SourceRepository> GetSortedRepositories()
{
var tempRepos = SourceRepositoryProvider.GetRepositories().ToList();
var sortedRepositories = new List <SourceRepository>();
// 1.Local
int idx = tempRepos.FindIndex(a => a.PackageSource.IsLocal);
if (idx >= 0)
{
sortedRepositories.Add(tempRepos[idx]);
tempRepos.RemoveAt(idx);
}
// 2.nuget.org
idx = tempRepos.FindIndex(a => a.PackageSource.Name.Equals("nuget.org"));
if (idx >= 0)
{
sortedRepositories.Add(tempRepos[idx]);
tempRepos.RemoveAt(idx);
}
// 3.Official
idx = tempRepos.FindIndex(a => a.PackageSource.IsOfficial);
if (idx >= 0)
{
sortedRepositories.Add(tempRepos[idx]);
tempRepos.RemoveAt(idx);
}
// 4.others
foreach (var r in tempRepos)
{
sortedRepositories.Add(r);
}
return(sortedRepositories);
}
private void RunScript(string scriptText, params string[] parameters)
{
ISettings settings = Settings.LoadDefaultSettings(Environment.ExpandEnvironmentVariables("%systemdrive%"), null, null);
var packageSourceProvider = new PackageSourceProvider(settings);
var packageSources = packageSourceProvider.LoadPackageSources();
SourceRepositoryProvider provider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
PowerShell ps = PowerShell.Create();
ps.Runspace = _runSpace;
ps.Commands.AddCommand(scriptText);
// Run the scriptText
var testCommand = ps.Commands.Commands[0];
testCommand.Parameters.Add("Id", parameters[0]);
testCommand.Parameters.Add("Version", parameters[1]);
// Add as a test hook to pass in the provider
testCommand.Parameters.Add("SourceRepositoryProvider", provider);
testCommand.Parameters.Add("VsSolutionManager", new TestSolutionManager());
// Add out-string
ps.Commands.AddCommand("Out-String");
// execute the script
foreach (PSObject result in ps.Invoke())
{
Console.WriteLine(result.ToString());
}
// close the runspace
_runSpace.Close();
}
public async Task GetDeps(XElement project, List <Package> packages)
{
IEnumerable <NuGetFramework> frameworks =
project.Descendants()
.Where(x => x.Name.LocalName == "TargetFramework" || x.Name.LocalName == "TargetFrameworks")
.SingleOrDefault()
.Value.Split(';')
.Select(f => NuGetFramework.ParseFolder(f));
AuditEnvironment.Info("{0}", frameworks.First().Framework);
var nugetPackages = packages.Select(p => new PackageIdentity(p.Name, NuGetVersion.Parse(p.Version)));
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var logger = NullLogger.Instance;
using (var cacheContext = new SourceCacheContext())
{
foreach (var np in nugetPackages)
{
foreach (var sourceRepository in sourceRepositoryProvider.GetRepositories())
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
np, frameworks.First(), cacheContext, logger, CancellationToken.None);
if (dependencyInfo != null)
{
AuditEnvironment.Info("Dependency info: {0}.", dependencyInfo);
}
}
}
}
}
/// <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);
}
}
}
public RegistryCache(string rootPersistentFolder, Uri rootHttpUri, string unityScope, string minimumUnityVersion,
string packageNameNuGetPostFix, RegistryTargetFramework[] targetFrameworks, ILogger logger)
{
_rootPersistentFolder = rootPersistentFolder ?? throw new ArgumentNullException(nameof(rootPersistentFolder));
_rootHttpUri = rootHttpUri ?? throw new ArgumentNullException(nameof(rootHttpUri));
_unityScope = unityScope ?? throw new ArgumentNullException(nameof(unityScope));
_minimumUnityVersion = minimumUnityVersion ?? throw new ArgumentNullException(nameof(minimumUnityVersion));
_packageNameNuGetPostFix = packageNameNuGetPostFix ?? throw new ArgumentNullException(nameof(packageNameNuGetPostFix));
_targetFrameworks = targetFrameworks ?? throw new ArgumentNullException(nameof(targetFrameworks));
if (!Directory.Exists(_rootPersistentFolder))
{
Directory.CreateDirectory(_rootPersistentFolder);
}
_settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(_settings), Repository.Provider.GetCoreV3());
_sourceRepository = sourceRepositoryProvider.GetRepositories().FirstOrDefault();
_logger = logger;
_registry = Registry.GetInstance();
// Initialize target framework
foreach (var registryTargetFramework in _targetFrameworks)
{
registryTargetFramework.Framework = NuGetFramework.Parse(registryTargetFramework.Name);
}
_sourceCacheContext = new SourceCacheContext();
_npmPackageRegistry = new NpmPackageRegistry();
}
private async Task <IEnumerable <NuGetProjectAction> > PacManCleanInstall(SourceRepositoryProvider sourceRepositoryProvider, PackageIdentity target)
{
// Arrange
using (var testSolutionManager = new TestSolutionManager())
using (var randomPackagesConfigFolderPath = TestDirectory.Create())
{
var testSettings = NullSettings.Instance;
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 virtual Task <PackageRestoreResult> RestoreMissingPackagesAsync(string solutionDirectory,
IEnumerable <PackageRestoreData> packages,
INuGetProjectContext nuGetProjectContext,
PackageDownloadContext downloadContext,
ILogger logger,
CancellationToken token)
{
if (packages == null)
{
throw new ArgumentNullException(nameof(packages));
}
var nuGetPackageManager = GetNuGetPackageManager(solutionDirectory);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packages,
token,
PackageRestoredEvent,
PackageRestoreFailedEvent,
sourceRepositories: SourceRepositoryProvider.GetRepositories(),
maxNumberOfParallelTasks: PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: logger);
if (nuGetProjectContext.PackageExtractionContext == null)
{
nuGetProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings, packageRestoreContext.Logger),
packageRestoreContext.Logger);
}
return(RestoreMissingPackagesAsync(packageRestoreContext, nuGetProjectContext, downloadContext));
}
public async void installPackagesFromProvidedAppSettingsFileAsync()
{
var serachResult = await _packageSearcher.GetSinglePackageMetaDataAsync();
var identity = serachResult.Identity;
var rootPath = @"myPathToTheFolder";
ISettings settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings());
PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings);
ISourceRepositoryProvider sourceRepositoryProvider =
new SourceRepositoryProvider(packageSourceProvider, GetV3AndV2Providers());
var project = new FolderNuGetProject(rootPath);
string packagesPath = "...";
NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath)
{
PackagesFolderNuGetProject = project
};
bool allowPrereleaseVersions = true;
bool allowUnlisted = false;
ResolutionContext resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None);
INuGetProjectContext projectContext = new DefaultProjectContext();
IEnumerable <SourceRepository> sourceRepositories = Enumerable.Repeat(_packageSearcher.GetSourceRepository(), 1);
await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
identity, resolutionContext, projectContext, sourceRepositories,
Array.Empty <SourceRepository>(),
CancellationToken.None);
}
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, false);
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);
}
public async override Task ExecuteCommand()
{
IEnumerable <SourceRepository> sourceRepository;
if (Source.Any())
{
List <SourceRepository> sourceList = new List <SourceRepository>();
foreach (var source in Source)
{
sourceList.Add(new SourceRepository(new PackageSource(source), ResourceProviders));
}
sourceRepository = sourceList;
}
else
{
var packageSourceProvider = new PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
sourceRepository = sourceRepositoryProvider.GetRepositories();
}
var selfUpdater = new SelfUpdater(sourceRepository.FirstOrDefault())
{
Console = Console
};
await selfUpdater.UpdateSelf();
}
private RemoteWalkContext CreateRemoteWalkContext(ISettings settings, SourceCacheContext cache, ILogger logger)
{
// nuget.org etc.
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
var localRepository = Repository.Factory.GetCoreV3(globalPackagesFolder, FeedType.FileSystemV3);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var context = new RemoteWalkContext(cache, logger);
context.LocalLibraryProviders.Add(new SourceRepositoryDependencyProvider(localRepository, logger, cache,
ignoreFailedSources: true,
fileCache: new LocalPackageFileCache(),
ignoreWarning: true,
isFallbackFolderSource: false));
foreach (var remoteRepository in sourceRepositoryProvider.GetRepositories())
{
context.RemoteLibraryProviders.Add(new SourceRepositoryDependencyProvider(remoteRepository, logger, cache,
ignoreFailedSources: cache.IgnoreFailedSources,
fileCache: new LocalPackageFileCache(),
ignoreWarning: false,
isFallbackFolderSource: false));
}
return(context);
}
public static async Task UninstallPackage(string packageId, string version, ILogger logger = null)
{
if (logger == null)
{
logger = new ConsoleNuGetLogger(IoC.Get <IConsole>());
}
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
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);
}
}
public async override Task ExecuteCommand()
{
CalculateEffectivePackageSaveMode();
string installPath = ResolveInstallPath();
var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
IEnumerable <SourceRepository> primarySources;
IEnumerable <SourceRepository> secondarySources;
GetEffectiveSources(sourceRepositoryProvider, out primarySources, out secondarySources);
if (Arguments.Count == 0)
{
throw new InvalidOperationException(NuGetResources.InstallCommandPackageIdMustBeProvided);
}
string packageId = Arguments[0];
NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, installPath);
ResolutionContext resolutionContext = new ResolutionContext(dependencyBehavior: DependencyBehavior, includePrelease: Prerelease);
FolderNuGetProject nugetProject = new FolderNuGetProject(installPath);
nugetProject.PackageSaveMode = EffectivePackageSaveMode;
if (Version == null)
{
await packageManager.InstallPackageAsync(nugetProject, packageId, resolutionContext, new Common.Console(),
primarySources, secondarySources, CancellationToken.None);
}
else
{
await packageManager.InstallPackageAsync(nugetProject, new PackageIdentity(packageId, new NuGetVersion(Version)), resolutionContext,
new Common.Console(), primarySources, secondarySources, CancellationToken.None);
}
}
public virtual async Task <IEnumerable <SourcePackageDependencyInfo> > GetDependenciesAsync(PackageIdentity identity, SourceCacheContext cacheContext)
{
var packageSourceProvider = new PackageSourceProvider(m_NugetSettings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, m_Providers);
var sourceRepositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependenciesAsync(identity, cacheContext, sourceRepositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
return(m_PackageResolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x
=> PackageIdentityComparer.Default.Equals(x, p)))
.Where(d => !m_IgnoredDependendencies.Contains(d.Id)));
}
public virtual async Task <IEnumerable <IPackageSearchMetadata> > QueryPackagesAsync(string packageId, string version = null, bool includePreRelease = false)
{
var matches = new List <IPackageSearchMetadata>();
Logger.LogInformation("Searching repository for package: " + packageId);
var packageSourceProvider = new PackageSourceProvider(m_NugetSettings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, m_Providers);
var sourceRepositories = sourceRepositoryProvider.GetRepositories();
foreach (var sourceRepository in sourceRepositories)
{
var searchResource = await sourceRepository.GetResourceAsync <PackageSearchResource>();
var searchFilter = new SearchFilter(includePreRelease)
{
IncludeDelisted = false,
SupportedFrameworks = new[] { m_CurrentFramework.DotNetFrameworkName }
};
IEnumerable <IPackageSearchMetadata> searchResult;
try
{
searchResult = (await searchResource.SearchAsync(packageId, searchFilter, 0, 10, Logger, CancellationToken.None)).ToList();
}
catch (Exception ex)
{
Logger.LogDebug("Could not find package: ");
Logger.LogDebug(ex.ToString());
continue;
}
if (version == null)
{
Logger.LogDebug("version == null, adding searchResult: " + searchResult.Count());
matches.AddRange(searchResult);
continue;
}
foreach (var packageMeta in searchResult)
{
var versions = (await packageMeta.GetVersionsAsync()).ToList();
if (!versions.Any(d
=> d.Version.OriginalVersion.Equals(version, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
Logger.LogDebug("adding packageMeta: "
+ packageMeta.Identity.Id
+ ":"
+ packageMeta.Identity.Version);
matches.Add(packageMeta);
}
}
return(matches);
}
public static async Task InstallPackage(string packageId, string version, ILogger logger = null, int chmodFileMode = DefaultFilePermissions)
{
if (logger == null)
{
logger = new ConsoleNuGetLogger(IoC.Get <IConsole>());
}
PackageIdentity identity = new PackageIdentity(packageId, new NuGet.Versioning.NuGetVersion(version));
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(Platform.ReposDirectory, null, new MachineWideSettings(), false, true);
ISourceRepositoryProvider sourceRepositoryProvider = new SourceRepositoryProvider(settings, s_providers); // See part 2
using (var installedPackageCache = GetCache())
{
var project = new AvalonStudioExtensionsFolderProject(GetFramework(), installedPackageCache, Platform.ReposDirectory);
if (!project.PackageExists(identity))
{
var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, Platform.ReposDirectory)
{
PackagesFolderNuGetProject = project,
};
bool allowPrereleaseVersions = true;
bool allowUnlisted = false;
ResolutionContext resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None);
INuGetProjectContext projectContext = new ProjectContext(logger);
await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
identity, resolutionContext, projectContext, s_sourceRepositories,
Array.Empty <SourceRepository>(), // This is a list of secondary source respositories, probably empty
CancellationToken.None);
var packageDir = GetPackageDirectory(identity);
var files = Directory.EnumerateFiles(packageDir, "*.*", SearchOption.AllDirectories);
if (Platform.PlatformIdentifier != Platforms.PlatformID.Win32NT)
{
logger.LogInformation("Applying file attributes.");
foreach (var file in files)
{
Platform.Chmod(file, chmodFileMode);
}
}
await LoadAssetsFromFilesAsync(packageId, version, files);
}
else
{
logger.LogInformation("Package is already installed.");
}
}
}
internal PackageInstaller(IFileSystem fileSystem, AssemblyLoader assemblyLoader)
{
_fileSystem = fileSystem;
_assemblyLoader = assemblyLoader;
_currentFramework = GetCurrentFramework();
_settings = Settings.LoadDefaultSettings(fileSystem.RootPath.FullPath, null, new MachineWideSettings());
_sourceRepositories = new SourceRepositoryProvider(_settings);
}
public override SourceRepositoryProvider CreateSourceRepositoryProvider(ISettings s)
{
var srp = new SourceRepositoryProvider(s, Core.CoreConfig.Updates.PluginsUpdateNuGetUrls);
SetAlphaRepoEnabledState(srp);
return(srp);
}
private SourceRepository GetRepository()
{
var sourceRepositoryProvider = new SourceRepositoryProvider(Settings.LoadDefaultSettings(_directory), Repository.Provider.GetCoreV3());
var repos = sourceRepositoryProvider.GetRepositories();
var result = repos.Single(x => x.PackageSource.Name == "nuget.org");
return(result);
}
static IEnumerable <SourceRepository> GetSourceRepositories()
{
string directory = Path.GetDirectoryName(typeof(MainClass).Assembly.Location);
var settings = Settings.LoadDefaultSettings(directory, null, null);
var provider = new SourceRepositoryProvider(settings, Repository.Provider.GetVisualStudio());
return(provider.GetRepositories());
}
protected void GetEffectiveSources(SourceRepositoryProvider sourceRepositoryProvider, out IEnumerable<SourceRepository> primarySources, out IEnumerable<SourceRepository> secondarySources)
{
var enabledConfiguredSources = sourceRepositoryProvider.GetRepositories().Where(s => s.PackageSource.IsEnabled);
var sourceRepositoriesFromSourceSwitch = GetSourceRepositoriesFromSourceSwitch(sourceRepositoryProvider);
if (sourceRepositoriesFromSourceSwitch != null && sourceRepositoriesFromSourceSwitch.Any())
{
primarySources = sourceRepositoriesFromSourceSwitch;
secondarySources = enabledConfiguredSources;
}
else
{
primarySources = enabledConfiguredSources;
secondarySources = Enumerable.Empty<SourceRepository>();
}
if(primarySources == null || !primarySources.Any())
{
throw new InvalidOperationException(NuGetResources.DownloadCommandBaseNoEnabledPackageSource);
}
}
public async override Task ExecuteCommand()
{
IEnumerable<SourceRepository> sourceRepository;
string searchTerm = Arguments != null ? Arguments.FirstOrDefault() : null;
if (Source.Any())
{
List<SourceRepository> sourceList = new List<SourceRepository>();
foreach (var source in Source)
{
sourceList.Add(new SourceRepository(new PackageSource(source), ResourceProviders));
}
sourceRepository = sourceList;
}
else
{
var packageSourceProvider = new PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
sourceRepository = sourceRepositoryProvider.GetRepositories();
}
foreach (var eachRepository in sourceRepository)
{
var searchResource = await eachRepository.GetResourceAsync<SimpleSearchResource>();
if (searchResource != null)
{
int page = 100;
int skip = 0;
do
{
var packages = await searchResource.Search(searchTerm, new SearchFilter() { IncludePrerelease = Prerelease, SupportedFrameworks = new string[0] }, skip, page, CancellationToken.None);
skip += page;
if (!packages.Any()) break;
PrintPackages(packages);
}
while (true);
}
}
}
protected IEnumerable<SourceRepository> GetSourceRepositoriesFromSourceSwitch(SourceRepositoryProvider sourceRepositoryProvider)
{
if (Source != null && Source.Any())
{
List<SourceRepository> sourceRepositories = new List<SourceRepository>();
foreach (var source in Source)
{
sourceRepositories.Add(sourceRepositoryProvider.CreateRepository(new NuGet.Configuration.PackageSource(source)));
}
return sourceRepositories;
}
return null;
}
public async override Task ExecuteCommand()
{
CalculateEffectivePackageSaveMode();
DetermineRestoreMode();
if (_restoringForSolution && !String.IsNullOrEmpty(SolutionDirectory))
{
// option -SolutionDirectory is not valid when we are restoring packages for a solution
throw new InvalidOperationException(LocalizedResourceManager.GetString("RestoreCommandOptionSolutionDirectoryIsInvalid"));
}
string packagesFolderPath = GetPackagesFolderPath();
var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, packagesFolderPath);
HashSet<PackageReference> installedPackageReferences;
Stopwatch watch = new Stopwatch();
if (_restoringForSolution)
{
watch.Restart();
installedPackageReferences = GetInstalledPackageReferencesFromSolutionFile(_solutionFileFullPath);
watch.Stop();
DisplayExecutedTime(watch.Elapsed, "GetInstalledPackageReferencesFromSolution");
}
else
{
// By default the PackageReferenceFile does not throw if the file does not exist at the specified path.
// So we'll need to verify that the file exists.
if (!File.Exists(_packagesConfigFileFullPath))
{
string message = String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("RestoreCommandFileNotFound"), _packagesConfigFileFullPath);
throw new InvalidOperationException(message);
}
watch.Restart();
installedPackageReferences = GetInstalledPackageReferences(_packagesConfigFileFullPath);
watch.Stop();
DisplayExecutedTime(watch.Elapsed, "GetInstalledPackageReferences");
}
watch.Restart();
var missingPackages = PackageRestoreManager.GetMissingPackages(nuGetPackageManager, installedPackageReferences);
watch.Stop();
DisplayExecutedTime(watch.Elapsed, "GetMissingPackages");
watch.Restart();
// If sourceRepositories parameter below is null, then the sourceRepositories from the SourceRepositoryProvider in NuGetPackageManager will be used
await PackageRestoreManager.RestoreMissingPackages(nuGetPackageManager, missingPackages, Console, CancellationToken.None,
packageRestoredEvent: null, sourceRepositories: GetSourceRepositoriesFromSourceSwitch(sourceRepositoryProvider));
watch.Stop();
DisplayExecutedTime(watch.Elapsed, "RestorePackages");
}
