private List <SourceRepository> GetEffectiveSourcesCore(ISettings settings)
{
var sourceObjects = new Dictionary <string, PackageSource>(StringComparer.Ordinal);
var packageSourceProvider = new PackageSourceProvider(settings);
var packageSourcesFromProvider = packageSourceProvider.LoadPackageSources();
var useNugetConfigSources = (Sources.Count == 0);
// Always use passed-in sources and fallback sources
foreach (var sourceUri in Enumerable.Concat(Sources, FallbackSources))
{
sourceObjects[sourceUri] = new PackageSource(sourceUri);
}
// Use PackageSource objects from the provider when possible (since those will have credentials from nuget.config)
foreach (var source in packageSourcesFromProvider)
{
if (source.IsEnabled && (useNugetConfigSources || sourceObjects.ContainsKey(source.Source)))
{
sourceObjects[source.Source] = source;
}
}
if (CachingSourceProvider == null)
{
// Create a shared caching provider if one does not exist already
CachingSourceProvider = new CachingSourceProvider(packageSourceProvider);
}
return(sourceObjects.Select(entry => CachingSourceProvider.CreateRepository(entry.Value)).ToList());
}
private List <SourceRepository> GetEffectiveSourcesCore(ISettings settings, IList <PackageSource> dgSpecSources)
{
var sourceObjects = dgSpecSources.ToDictionary(k => k.Source, v => v, StringComparer.Ordinal);
var packageSourceProvider = new PackageSourceProvider(settings);
var packageSourcesFromProvider = packageSourceProvider.LoadPackageSources();
foreach (var sourceUri in Sources)
{
//DGSpecSources should always match the Sources
if (!sourceObjects.ContainsKey(sourceUri))
{
Log.LogDebug($"{sourceUri} is in the RestoreArgs Sources but in the passed in dgSpecSources");
sourceObjects[sourceUri] = new PackageSource(sourceUri);
}
}
// Use PackageSource objects from the provider when possible (since those will have credentials from nuget.config)
foreach (var source in packageSourcesFromProvider)
{
if (source.IsEnabled && (sourceObjects.ContainsKey(source.Source)))
{
sourceObjects[source.Source] = source;
}
}
if (CachingSourceProvider == null)
{
// Create a shared caching provider if one does not exist already
CachingSourceProvider = new CachingSourceProvider(packageSourceProvider);
}
return(sourceObjects.Select(entry => CachingSourceProvider.CreateRepository(entry.Value)).ToList());
}
/// <summary>
/// Create a restore context.
/// </summary>
private static RestoreArgs GetRestoreContext(
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
SourceCacheContext sourceCacheContext,
IEnumerable <SourceRepository> sources,
DependencyGraphSpec dgFile,
bool forceRestore)
{
var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings));
foreach (var source in sources)
{
caching.AddSourceRepository(source);
}
var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile);
var restoreContext = new RestoreArgs()
{
CacheContext = sourceCacheContext,
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
dgProvider
},
Log = context.Logger,
AllowNoOp = !forceRestore,
CachingSourceProvider = caching
};
return(restoreContext);
}
public static async Task <PackageUpdateResource> GetPackageUpdateResource(IPackageSourceProvider sourceProvider, PackageSource packageSource)
{
var sourceRepositoryProvider = new CachingSourceProvider(sourceProvider);
var sourceRepository = sourceRepositoryProvider.CreateRepository(packageSource);
return(await sourceRepository.GetResourceAsync <PackageUpdateResource>());
}
private CachingSourceProvider GetSourceRepositoryProvider()
{
if (_sourceProvider == null)
{
_sourceProvider = new CachingSourceProvider(SourceProvider);
}
return(_sourceProvider);
}
private RestoreSummaryRequest Create(
string inputPath,
RestoreArgs restoreContext)
{
var file = new FileInfo(inputPath);
// Get settings relative to the input file
var settings = restoreContext.GetSettings(file.DirectoryName);
// BUGFIX
// The null here causes an exception downstream. Instead, inline the important code.
//var sources = restoreContext.GetEffectiveSources(settings, null);
var packageSourceProvider = new PackageSourceProvider(settings);
CachingSourceProvider cachingSourceProvider = new CachingSourceProvider(packageSourceProvider);
var sources = packageSourceProvider
.LoadPackageSources()
.Select(cachingSourceProvider.CreateRepository)
.ToList();
// END BUGFIX
var FallbackPackageFolders = restoreContext.GetEffectiveFallbackPackageFolders(settings);
var globalPath = restoreContext.GetEffectiveGlobalPackagesFolder(file.DirectoryName, settings);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
FallbackPackageFolders,
sources,
restoreContext.CacheContext,
restoreContext.Log);
var project = JsonPackageSpecReader.GetPackageSpec(file.Directory.Name, file.FullName);
// BUGFIX
// ApplyStandardProperties tries to access RestoreMetadata with no null check. Add
// a default value.
project.RestoreMetadata = new ProjectRestoreMetadata();
// END BUGFIX
var request = new RestoreRequest(
project,
sharedCache,
restoreContext.CacheContext,
restoreContext.Log);
restoreContext.ApplyStandardProperties(request);
IEnumerable <string> configFiles = SettingsUtility.GetConfigFilePaths(settings);
var summaryRequest = new RestoreSummaryRequest(request, inputPath, configFiles, sources);
return(summaryRequest);
}
private List <SourceRepository> GetEffectiveSourcesCore(ISettings settings)
{
// Take the passed in sources
var packageSources = new HashSet <string>(Sources, StringComparer.Ordinal);
var sourceObjects = new Dictionary <string, PackageSource>(StringComparer.Ordinal);
var packageSourceProvider = new Lazy <PackageSourceProvider>(()
=> new PackageSourceProvider(settings));
// If no sources were passed in use the NuGet.Config sources
if (packageSources.Count < 1)
{
// Add enabled sources
foreach (var source in packageSourceProvider.Value.LoadPackageSources())
{
if (source.IsEnabled)
{
sourceObjects[source.Source] = source;
}
}
var enabledSources = sourceObjects.Values
.Select(source => source.Source)
.Distinct(StringComparer.Ordinal)
.ToList();
packageSources.UnionWith(enabledSources);
}
// Always add fallback sources
packageSources.UnionWith(FallbackSources);
if (CachingSourceProvider == null)
{
// Create a shared caching provider if one does not exist already
CachingSourceProvider = new CachingSourceProvider(packageSourceProvider.Value);
}
return(packageSources.Select(sourceUri =>
{
PackageSource source;
if (!sourceObjects.TryGetValue(sourceUri, out source))
{
source = new PackageSource(sourceUri);
}
return CachingSourceProvider.CreateRepository(source);
}).ToList());
}
public static async Task <SymbolPackageUpdateResourceV3> GetSymbolPackageUpdateResource(IPackageSourceProvider sourceProvider, string source)
{
// Use a loaded PackageSource if possible since it contains credential info
var packageSource = sourceProvider.LoadPackageSources()
.Where(e => e.IsEnabled && string.Equals(source, e.Source, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
if (packageSource == null)
{
packageSource = new PackageSource(source);
}
var sourceRepositoryProvider = new CachingSourceProvider(sourceProvider);
var sourceRepository = sourceRepositoryProvider.CreateRepository(packageSource);
return(await sourceRepository.GetResourceAsync <SymbolPackageUpdateResourceV3>());
}
public async Task <bool> DownloadPackagesAsync(ICollection <PackageDownloadRequest> requests, TimeSpan timeout, CancellationToken cancellationToken)
{
logger.LogMinimal($"Downloading {requests.Count} package(s)");
var cts = new CancellationTokenSource(timeout);
cancellationToken.Register(() => cts.Cancel());
using (var cacheContext = new SourceCacheContext())
using (var throttle = new SemaphoreSlim(8))
{
var defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings));
var tasks = new List <Task <bool> >();
foreach (var request in requests)
{
var feeds = request.Sources
.Select(s => s?.Trim())
.Where(s => !string.IsNullOrEmpty(s))
.Distinct()
.Select(sourceProvider.CreateRepository);
tasks.Add(DownloadPackageAsync(request, feeds, cacheContext, throttle, logger, cts.Token));
}
var all = Task.WhenAll(tasks);
var delay = Task.Delay(timeout);
var finished = await Task.WhenAny(all, delay);
if (ReferenceEquals(delay, finished))
{
logger.LogError($"Timed out after {timeout.TotalSeconds}s");
cts.Cancel();
return(false);
}
if (!tasks.All(a => a.Result))
{
logger.LogError("Failed to download all packages");
return(false);
}
return(true);
}
}
/// <summary>
/// Create a restore args.
/// </summary>
private static RestoreArgs GetRestoreArgs(
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
SourceCacheContext sourceCacheContext,
IEnumerable <SourceRepository> sources,
DependencyGraphSpec dgFile,
Guid parentId,
bool forceRestore,
bool isRestoreOriginalAction,
bool restoreForceEvaluate,
IReadOnlyList <IAssetsLogMessage> additionalMessasges,
IRestoreProgressReporter progressReporter)
{
#pragma warning disable CS0618 // Type or member is obsolete
var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings, enablePackageSourcesChangedEvent: false));
#pragma warning restore CS0618 // Type or member is obsolete
foreach (var source in sources)
{
caching.AddSourceRepository(source);
}
var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile);
var restoreContext = new RestoreArgs()
{
CacheContext = sourceCacheContext,
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
dgProvider
},
Log = context.Logger,
AllowNoOp = !forceRestore,
CachingSourceProvider = caching,
ParentId = parentId,
IsRestoreOriginalAction = isRestoreOriginalAction,
RestoreForceEvaluate = restoreForceEvaluate,
AdditionalMessages = additionalMessasges,
ProgressReporter = progressReporter,
};
return(restoreContext);
}
private static void Init(ISettings settings)
{
Dictionary <string, PackageSource> sourceObjects = new Dictionary <string, PackageSource>(StringComparer.Ordinal);
PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings);
IEnumerable <PackageSource> packageSourcesFromProvider = packageSourceProvider.LoadPackageSources();
// Use PackageSource objects from the provider when possible (since those will have credentials from nuget.config)
foreach (PackageSource source in packageSourcesFromProvider)
{
if (source.IsEnabled && !sourceObjects.ContainsKey(source.Source))
{
sourceObjects[source.Source] = source;
}
}
// Create a shared caching provider if one does not exist already
_cachingSourceProvider = _cachingSourceProvider ?? new CachingSourceProvider(packageSourceProvider);
List <SourceRepository> repos = sourceObjects.Select(entry => _cachingSourceProvider.CreateRepository(entry.Value)).ToList();
Repos.AddRange(repos);
}
private List <SourceRepository> GetEffectiveSourcesCore(ISettings settings, IList <PackageSource> dgSpecSources)
{
#pragma warning disable CS0618 // Type or member is obsolete
var packageSourceProvider = new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false);
#pragma warning restore CS0618 // Type or member is obsolete
var packageSourcesFromProvider = packageSourceProvider.LoadPackageSources();
var sourceObjects = new Dictionary <string, PackageSource>();
for (var i = 0; i < dgSpecSources.Count; i++)
{
sourceObjects[dgSpecSources[i].Source] = dgSpecSources[i];
}
foreach (var sourceUri in Sources)
{
//DGSpecSources should always match the Sources
if (!sourceObjects.ContainsKey(sourceUri))
{
Log.LogDebug($"{sourceUri} is in the RestoreArgs Sources but not in the passed in dgSpecSources");
sourceObjects[sourceUri] = new PackageSource(sourceUri);
}
}
// Use PackageSource objects from the provider when possible (since those will have credentials from nuget.config)
foreach (var source in packageSourcesFromProvider)
{
if (source.IsEnabled && (sourceObjects.ContainsKey(source.Source)))
{
sourceObjects[source.Source] = source;
}
}
if (CachingSourceProvider == null)
{
// Create a shared caching provider if one does not exist already
CachingSourceProvider = new CachingSourceProvider(packageSourceProvider);
}
return(sourceObjects.Select(entry => CachingSourceProvider.CreateRepository(entry.Value)).ToList());
}
public static async Task <PackageUpdateResource> GetPackageUpdateResource(IPackageSourceProvider sourceProvider, string source)
{
// Use a loaded PackageSource if possible since it contains credential info
PackageSource packageSource = null;
foreach (var loadedPackageSource in sourceProvider.LoadPackageSources())
{
if (loadedPackageSource.IsEnabled && source == loadedPackageSource.Source)
{
packageSource = loadedPackageSource;
break;
}
}
if (packageSource == null)
{
packageSource = new PackageSource(source);
}
var sourceRepositoryProvider = new CachingSourceProvider(sourceProvider);
var sourceRepository = sourceRepositoryProvider.CreateRepository(packageSource);
return(await sourceRepository.GetResourceAsync <PackageUpdateResource>());
}
private async Task <NuGetVersion> GetPackageVersion(VersionRange range)
{
if (!range.IsFloating)
{
return(range.MinVersion);
}
using (var cacheContext = new SourceCacheContext())
{
var log = new MSBuildLogger(Log);
var defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings));
var repo = sourceProvider.CreateRepository(new PackageSource(LineupPackageRestoreSource));
var metadata = await repo.GetResourceAsync <MetadataResource>();
if (!await metadata.Exists(LineupPackageId, cacheContext, log, _cts.Token))
{
Log.LogError($"Package {LineupPackageId} is not available on '{repo}'");
return(null);
}
try
{
var versions = await metadata.GetVersions(LineupPackageId, includePrerelease : true, includeUnlisted : false, sourceCacheContext : cacheContext, log : log, token : _cts.Token);
return(range.FindBestMatch(versions));
}
catch (Exception ex)
{
Log.LogError($"Unexpected error while fetching versions from {repo.PackageSource.Source}: " + ex.Message);
return(null);
}
}
}
/// <summary>
/// Устанавливает пакет.
/// </summary>
/// <param name="packageId">ID пакета.</param>
/// <param name="packageVersion">Версия пакета.</param>
/// <param name="allowPrerelease">Разрешена ли установка предварительного релиза.</param>
/// <returns>Содержимое установленного пакета.</returns>
public async Task<PackageContent> InstallPackage(string packageId, string packageVersion = null, bool allowPrerelease = false)
{
NuGetVersion packageNuGetVersion = null;
if (!string.IsNullOrWhiteSpace(packageVersion))
{
packageNuGetVersion = NuGetVersion.Parse(packageVersion);
}
// Конфигурационный файл NuGet.config по умолчанию
var settings = new NuGet.Configuration.Settings(_packagesPath, "NuGet.config");
// Фабрика источников пактов на основе конфигурационного файла
var packageSourceProvider = new PackageSourceProvider(settings);
// Добавление в фабрику источников пакетов дополнительных источников
packageSourceProvider.SavePackageSources(_packageSources.Select(i => new PackageSource(i)));
// Фабрика хранилищ пакетов на основе фабрики источников пакетов
var packageRepositoryProvider = new CachingSourceProvider(packageSourceProvider);
// Получение всех хранилищ пакетов на основе указанных источников
var packageRepositories = packageRepositoryProvider.GetRepositories().ToList();
// Определение возможности установки prerelease-версии пакетов
allowPrerelease = allowPrerelease || (packageNuGetVersion != null && packageNuGetVersion.IsPrerelease);
// Создание правил разрешения зависимостей при установке пакета
var resolutionContext = new ResolutionContext(
dependencyBehavior: DependencyBehavior.Lowest,
includePrelease: allowPrerelease,
includeUnlisted: true,
versionConstraints: VersionConstraints.None);
// Если версия пакета не указана, поиск последней версии
if (packageNuGetVersion == null)
{
packageNuGetVersion = await NuGetPackageManager.GetLatestVersionAsync(
packageId,
NuGetFramework.AnyFramework,
resolutionContext,
packageRepositories,
_logger,
CancellationToken.None);
if (packageNuGetVersion == null)
{
throw new InvalidOperationException(string.Format(Properties.Resources.PackageNotFound, packageId));
}
}
// Уникальный идентификатор версии пакета для установки
var packageIdentity = new PackageIdentity(packageId, packageNuGetVersion);
// Каталог для установки пакетов (каталог packages)
NuGetProject folderProject = new InfinniFolderNuGetProject(_packagesPath);
// Менеджер для управления пакетами
var packageManager = new NuGetPackageManager(packageRepositoryProvider, settings, _packagesPath);
// Правила установки пакетов
var projectContext = new NuGetLoggerProjectContext(_logger)
{
PackageExtractionContext = new PackageExtractionContext
{
PackageSaveMode = PackageSaveMode.Defaultv3
}
};
// Определение порядка действий при установке пакета
var installActions = (await packageManager.PreviewInstallPackageAsync(
folderProject,
packageIdentity,
resolutionContext,
projectContext,
packageRepositories,
Enumerable.Empty<SourceRepository>(),
CancellationToken.None)).ToList();
// Применение действий по установке пакета
await packageManager.ExecuteNuGetProjectActionsAsync(
folderProject,
installActions,
projectContext,
CancellationToken.None);
return GetPackageContent(packageIdentity, installActions.Select(i => i.PackageIdentity).ToList());
}
private static async Task <RestoreSummary> PerformNuGetV2RestoreAsync(Common.ILogger log, DependencyGraphSpec dgFile, bool noCache, bool disableParallel, bool interactive)
{
string globalPackageFolder = null;
string repositoryPath = null;
string firstPackagesConfigPath = null;
IList <PackageSource> packageSources = null;
var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer());
ISettings settings = null;
foreach (PackageSpec packageSpec in dgFile.Projects.Where(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig))
{
var pcRestoreMetadata = (PackagesConfigProjectRestoreMetadata)packageSpec.RestoreMetadata;
globalPackageFolder = globalPackageFolder ?? pcRestoreMetadata.PackagesPath;
repositoryPath = repositoryPath ?? pcRestoreMetadata.RepositoryPath;
if (packageSources == null)
{
packageSources = new List <PackageSource>();
if (!noCache)
{
if (!string.IsNullOrEmpty(globalPackageFolder) && Directory.Exists(globalPackageFolder))
{
packageSources.Add(new FeedTypePackageSource(globalPackageFolder, FeedType.FileSystemV3));
}
}
packageSources.AddRange(pcRestoreMetadata.Sources);
}
settings = settings ?? Settings.LoadSettingsGivenConfigPaths(pcRestoreMetadata.ConfigFilePaths);
var packagesConfigPath = Path.Combine(Path.GetDirectoryName(pcRestoreMetadata.ProjectPath), NuGetConstants.PackageReferenceFile);
firstPackagesConfigPath = firstPackagesConfigPath ?? packagesConfigPath;
installedPackageReferences.AddRange(GetInstalledPackageReferences(packagesConfigPath, allowDuplicatePackageIds: true, log));
}
if (string.IsNullOrEmpty(repositoryPath))
{
throw new InvalidOperationException(Strings.RestoreNoSolutionFound);
}
PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings);
var sourceRepositoryProvider = new CachingSourceProvider(packageSourceProvider);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, repositoryPath);
var effectivePackageSaveMode = CalculateEffectivePackageSaveMode(settings);
var packageSaveMode = effectivePackageSaveMode == Packaging.PackageSaveMode.None ?
Packaging.PackageSaveMode.Defaultv2 :
effectivePackageSaveMode;
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity, packageSaveMode)).ToArray();
if (missingPackageReferences.Length == 0)
{
return(new RestoreSummary(true));
}
var packageRestoreData = missingPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { firstPackagesConfigPath },
isMissing: true));
var repositories = sourceRepositoryProvider.GetRepositories().ToArray();
var installCount = 0;
var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>();
var collectorLogger = new RestoreCollectorLogger(log);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: (sender, args) => { Interlocked.Add(ref installCount, args.Restored ? 1 : 0); },
packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); },
sourceRepositories: repositories,
maxNumberOfParallelTasks: disableParallel
? 1
: PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: collectorLogger);
// TODO: Check require consent?
// NOTE: This feature is currently not working at all. See https://github.com/NuGet/Home/issues/4327
// CheckRequireConsent();
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, collectorLogger);
var projectContext = new ConsoleProjectContext(collectorLogger)
{
PackageExtractionContext = new PackageExtractionContext(
packageSaveMode,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext,
collectorLogger)
};
if (effectivePackageSaveMode != Packaging.PackageSaveMode.None)
{
projectContext.PackageExtractionContext.PackageSaveMode = packageSaveMode;
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = noCache;
var downloadContext = new PackageDownloadContext(cacheContext, repositoryPath, directDownload: false)
{
ClientPolicyContext = clientPolicyContext
};
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive);
var result = await PackageRestoreManager.RestoreMissingPackagesAsync(
packageRestoreContext,
projectContext,
downloadContext);
return(new RestoreSummary(
result.Restored,
"packages.config projects",
settings.GetConfigFilePaths().ToArray(),
packageSources.Select(x => x.Source).ToArray(),
installCount,
collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents)).ToArray()
));
}
}
private async Task <bool> ExecuteAsync(Common.ILogger log)
{
if (RestoreGraphItems.Length < 1)
{
log.LogWarning(Strings.NoProjectsProvidedToTask);
return(true);
}
// Set user agent and connection settings.
ConfigureProtocol();
// Convert to the internal wrapper
var wrappedItems = RestoreGraphItems.Select(MSBuildUtility.WrapMSBuildItem);
//var graphLines = RestoreGraphItems;
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = RestoreNoCache;
cacheContext.IgnoreFailedSources = RestoreIgnoreFailedSources;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>();
var dgFile = MSBuildRestoreUtility.GetDependencySpec(wrappedItems);
if (dgFile.Restore.Count < 1)
{
// Restore will fail if given no inputs, but here we should skip it and provide a friendly message.
log.LogMinimal(Strings.NoProjectsToRestore);
return(true);
}
// Add all child projects
if (RestoreRecursive)
{
BuildTasksUtility.AddAllProjectsForRestore(dgFile);
}
providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgFile));
var defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
ConfigFile = MSBuildStringUtility.TrimAndGetNullForEmpty(RestoreConfigFile),
DisableParallel = RestoreDisableParallel,
GlobalPackagesFolder = RestorePackagesPath,
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
PreLoadedRequestProviders = providers,
CachingSourceProvider = sourceProvider,
AllowNoOp = !RestoreForce,
HideWarningsAndErrors = HideWarningsAndErrors
};
if (!string.IsNullOrEmpty(RestoreSources))
{
var sources = MSBuildStringUtility.Split(RestoreSources);
restoreContext.Sources.AddRange(sources);
}
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
_cts.Token.ThrowIfCancellationRequested();
var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token);
// Summary
RestoreSummary.Log(log, restoreSummaries);
return(restoreSummaries.All(x => x.Success));
}
}
public static void Register(
CommandLineApplication cmdApp,
Func <CommandOutputLogger> getLogger)
{
cmdApp.Command("restore", (Action <CommandLineApplication>)(restore =>
{
restore.Description = Strings.Restore_Description;
restore.HelpOption(XPlatUtility.HelpOption);
restore.Option(
CommandConstants.ForceEnglishOutputOption,
Strings.ForceEnglishOutput_Description,
CommandOptionType.NoValue);
var sources = restore.Option(
"-s|--source <source>",
Strings.Restore_Switch_Source_Description,
CommandOptionType.MultipleValue);
var packagesDirectory = restore.Option(
"--packages <packagesDirectory>",
Strings.Restore_Switch_Packages_Description,
CommandOptionType.SingleValue);
var disableParallel = restore.Option(
"--disable-parallel",
Strings.Restore_Switch_DisableParallel_Description,
CommandOptionType.NoValue);
var fallBack = restore.Option(
"-f|--fallbacksource <FEED>",
Strings.Restore_Switch_Fallback_Description,
CommandOptionType.MultipleValue);
var configFile = restore.Option(
"--configfile <file>",
Strings.Restore_Switch_ConfigFile_Description,
CommandOptionType.SingleValue);
var noCache = restore.Option(
"--no-cache",
Strings.Restore_Switch_NoCache_Description,
CommandOptionType.NoValue);
var inferRuntimes = restore.Option(
"--infer-runtimes",
"Temporary option to allow NuGet to infer RIDs for legacy repositories",
CommandOptionType.NoValue);
var verbosity = restore.Option(
XPlatUtility.VerbosityOption,
Strings.Switch_Verbosity,
CommandOptionType.SingleValue);
var argRoot = restore.Argument(
"[root]",
Strings.Restore_Arg_ProjectName_Description,
multipleValues: true);
var ignoreFailedSources = restore.Option(
"--ignore-failed-sources",
Strings.Restore_Switch_IgnoreFailedSource_Description,
CommandOptionType.NoValue);
restore.OnExecute(async() =>
{
var log = getLogger();
if (verbosity.HasValue())
{
log.LogLevel = XPlatUtility.GetLogLevel(verbosity);
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = noCache.HasValue();
cacheContext.IgnoreFailedSources = ignoreFailedSources.HasValue();
var providerCache = new RestoreCommandProvidersCache();
// Ordered request providers
var providers = new List <IRestoreRequestProvider>();
providers.Add(new MSBuildP2PRestoreRequestProvider(providerCache));
providers.Add(new ProjectJsonRestoreRequestProvider(providerCache));
ISettings defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
CachingSourceProvider sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
ConfigFile = configFile.HasValue() ? configFile.Value() : null,
DisableParallel = disableParallel.HasValue(),
GlobalPackagesFolder = packagesDirectory.HasValue() ? packagesDirectory.Value() : null,
Inputs = new List <string>(argRoot.Values),
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
RequestProviders = providers,
Sources = sources.Values,
FallbackSources = fallBack.Values,
CachingSourceProvider = sourceProvider
};
if (inferRuntimes.HasValue())
{
var runtimeOSname = PlatformApis.GetRuntimeOsName();
var os = PlatformApis.GetOSName();
var defaultRuntimes = RequestRuntimeUtility.GetDefaultRestoreRuntimes(os, runtimeOSname);
restoreContext.FallbackRuntimes.UnionWith(defaultRuntimes);
}
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
var restoreSummaries = await RestoreRunner.Run(restoreContext);
// Summary
RestoreSummary.Log(log, restoreSummaries);
return(restoreSummaries.All(x => x.Success) ? 0 : 1);
}
});
}));
}
/// <summary>
/// Устанавливает пакет.
/// </summary>
/// <param name="packageId">ID пакета.</param>
/// <param name="packageVersion">Версия пакета.</param>
/// <param name="allowPrerelease">Разрешена ли установка предварительного релиза.</param>
/// <returns>Содержимое установленного пакета.</returns>
public async Task <PackageContent> InstallPackage(string packageId, string packageVersion = null, bool allowPrerelease = false)
{
NuGetVersion packageNuGetVersion = null;
if (!string.IsNullOrWhiteSpace(packageVersion))
{
packageNuGetVersion = NuGetVersion.Parse(packageVersion);
}
// Конфигурационный файл NuGet.config по умолчанию
var settings = new NuGet.Configuration.Settings(_packagesPath, "NuGet.config");
// Фабрика источников пактов на основе конфигурационного файла
var packageSourceProvider = new PackageSourceProvider(settings);
// Добавление в фабрику источников пакетов дополнительных источников
packageSourceProvider.SavePackageSources(_packageSources.Select(i => new PackageSource(i)));
// Фабрика хранилищ пакетов на основе фабрики источников пакетов
var packageRepositoryProvider = new CachingSourceProvider(packageSourceProvider);
// Получение всех хранилищ пакетов на основе указанных источников
var packageRepositories = packageRepositoryProvider.GetRepositories().ToList();
// Определение возможности установки prerelease-версии пакетов
allowPrerelease = allowPrerelease || (packageNuGetVersion != null && packageNuGetVersion.IsPrerelease);
// Создание правил разрешения зависимостей при установке пакета
var resolutionContext = new ResolutionContext(
dependencyBehavior: DependencyBehavior.Lowest,
includePrelease: allowPrerelease,
includeUnlisted: true,
versionConstraints: VersionConstraints.None);
// Если версия пакета не указана, поиск последней версии
if (packageNuGetVersion == null)
{
packageNuGetVersion = await NuGetPackageManager.GetLatestVersionAsync(
packageId,
NuGetFramework.AnyFramework,
resolutionContext,
packageRepositories,
_logger,
CancellationToken.None);
if (packageNuGetVersion == null)
{
throw new InvalidOperationException(string.Format(Properties.Resources.PackageNotFound, packageId));
}
}
// Уникальный идентификатор версии пакета для установки
var packageIdentity = new PackageIdentity(packageId, packageNuGetVersion);
// Каталог для установки пакетов (каталог packages)
NuGetProject folderProject = new InfinniFolderNuGetProject(_packagesPath);
// Менеджер для управления пакетами
var packageManager = new NuGetPackageManager(packageRepositoryProvider, settings, _packagesPath);
// Правила установки пакетов
var projectContext = new NuGetLoggerProjectContext(_logger)
{
PackageExtractionContext = new PackageExtractionContext
{
PackageSaveMode = PackageSaveMode.Defaultv3
}
};
// Определение порядка действий при установке пакета
var installActions = (await packageManager.PreviewInstallPackageAsync(
folderProject,
packageIdentity,
resolutionContext,
projectContext,
packageRepositories,
Enumerable.Empty <SourceRepository>(),
CancellationToken.None)).ToList();
// Применение действий по установке пакета
await packageManager.ExecuteNuGetProjectActionsAsync(
folderProject,
installActions,
projectContext,
CancellationToken.None);
return(GetPackageContent(packageIdentity, installActions.Select(i => i.PackageIdentity).ToList()));
}
/// <summary>
/// Creates new instance of <see cref="BoundRestoreCommandUser"/> with given parameters.
/// </summary>
/// <param name="nugetSettings">The settings to use.</param>
/// <param name="thisFramework">The framework to bind to.</param>
/// <param name="runtimeIdentifier">The runtime identifier. Will be used by <see cref="E_NuGetUtils.ExtractAssemblyPaths{TResult}(BoundRestoreCommandUser, LockFile, Func{String, IEnumerable{String}, TResult}, GetFileItemsDelegate, IEnumerable{String})"/> method.</param>
/// <param name="runtimeGraph">Optional value indicating runtime graph information: either <see cref="global::NuGet.RuntimeModel.RuntimeGraph"/> directly, or <see cref="String"/> containing package ID of package holding <c>runtime.json</c> file, containing serialized runtime graph definition. If neither is specified, then <c>"Microsoft.NETCore.Platforms"</c> package ID used to locate <c>runtime.json</c> file, as per <see href="https://docs.microsoft.com/en-us/dotnet/core/rid-catalog">official documentation</see>.</param>
/// <param name="nugetLogger">The logger to use in restore command.</param>
/// <param name="sourceCacheContext">The optional <see cref="SourceCacheContext"/> to use.</param>
/// <param name="nuspecCache">The optional <see cref="LocalPackageFileCache"/> to use.</param>
/// <param name="clientPolicyContext">The optional <see cref="ClientPolicyContext"/> to use.</param>
/// <param name="leaveSourceCacheOpen">Whether to leave the <paramref name="sourceCacheContext"/> open when disposing this <see cref="BoundRestoreCommandUser"/>.</param>
/// <param name="lockFileCacheDir">The directory where to store serialized lock files returned by <see cref="RestoreIfNeeded"/>. If <c>null</c> or empty, then <paramref name="lockFileCacheEnvironmentVariableName"/> will be used. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param>
/// <param name="lockFileCacheEnvironmentVariableName">The name of the environment variable containing the value for lock file cache directory. If <c>null</c> or empty, then environment variable reading will be skipped. If the environment variable itself is <c>null</c> or empty, then the user's home directory in conjunction with <paramref name="getDefaultLockFileCacheDir"/> will be used to deduce lock file cache directory. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param>
/// <param name="getDefaultLockFileCacheDir">This callback will be used when <paramref name="lockFileCacheEnvironmentVariableName"/> is <c>null</c> or empty or when the named environment variable itself was <c>null</c> or empty. This callback will receive current user's home directory as parameter and should return the lock file cache directory. If <c>null</c>, then <see cref="GetDefaultLockFileDir"/> will be used. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param>
/// <param name="disableLockFileCacheDir">This variable controls whether the results of <see cref="RestoreIfNeeded"/> will be stored to file system lock file cache directory. By default, the lock file caching is enabled. Set this parameter to <c>true</c> to completely disable caching lock files to file system.</param>
/// <exception cref="ArgumentNullException">If <paramref name="nugetSettings"/> is <c>null</c>.</exception>
public BoundRestoreCommandUser(
ISettings nugetSettings,
NuGetFramework thisFramework = null,
String runtimeIdentifier = null,
EitherOr <RuntimeGraph, String> runtimeGraph = default,
ILogger nugetLogger = null,
SourceCacheContext sourceCacheContext = null,
LocalPackageFileCache nuspecCache = null,
ClientPolicyContext clientPolicyContext = null,
Boolean leaveSourceCacheOpen = false,
String lockFileCacheDir = null,
String lockFileCacheEnvironmentVariableName = DEFAULT_LOCK_FILE_CACHE_DIR_ENV_NAME,
Func <String, String> getDefaultLockFileCacheDir = null,
Boolean disableLockFileCacheDir = false
)
{
ArgumentValidator.ValidateNotNull(nameof(nugetSettings), nugetSettings);
this.ThisFramework = thisFramework ?? NuGetUtility.TryAutoDetectThisProcessFramework();
if (nugetLogger == null)
{
nugetLogger = NullLogger.Instance;
}
var global = SettingsUtility.GetGlobalPackagesFolder(nugetSettings);
var fallbacks = SettingsUtility.GetFallbackPackageFolders(nugetSettings);
if (sourceCacheContext == null)
{
leaveSourceCacheOpen = false;
}
var ctx = sourceCacheContext ?? new SourceCacheContext();
var psp = new PackageSourceProvider(nugetSettings);
var csp = new CachingSourceProvider(psp);
this.RuntimeIdentifier = NuGetUtility.TryAutoDetectThisProcessRuntimeIdentifier(runtimeIdentifier);
this._cacheContext = ctx;
this._disposeSourceCacheContext = !leaveSourceCacheOpen;
this.NuGetLogger = nugetLogger;
this._restoreCommandProvider = RestoreCommandProviders.Create(
global,
fallbacks,
new PackageSourceProvider(nugetSettings).LoadPackageSources().Where(s => s.IsEnabled).Select(s => csp.CreateRepository(s)),
ctx,
nuspecCache ?? new LocalPackageFileCache(),
nugetLogger
);
this._nugetRestoreRootDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
this._restoreTargetFW = new TargetFrameworkInformation()
{
FrameworkName = this.ThisFramework
};
this.LocalRepositories = this._restoreCommandProvider.GlobalPackages.Singleton()
.Concat(this._restoreCommandProvider.FallbackPackageFolders)
.ToImmutableDictionary(r => r.RepositoryRoot, r => r);
this.RuntimeGraph = new Lazy <RuntimeGraph>(() =>
{
var rGraph = runtimeGraph.GetFirstOrDefault();
if (rGraph == null)
{
var packageName = runtimeGraph.GetSecondOrDefault();
if (String.IsNullOrEmpty(packageName))
{
packageName = DEFAULT_RUNTIME_GRAPH_PACKAGE_ID;
}
var platformsPackagePath = this.LocalRepositories.Values
.SelectMany(r => r.FindPackagesById(packageName))
.OrderByDescending(p => p.Version)
.FirstOrDefault()
?.ExpandedPath;
rGraph = String.IsNullOrEmpty(platformsPackagePath) ?
null :
JsonRuntimeFormat.ReadRuntimeGraph(Path.Combine(platformsPackagePath, global::NuGet.RuntimeModel.RuntimeGraph.RuntimeGraphFileName));
}
return(rGraph);
}, LazyThreadSafetyMode.ExecutionAndPublication);
if (!disableLockFileCacheDir)
{
this.DiskCacheDirectory = lockFileCacheDir
.OrIfNullOrEmpty(String.IsNullOrEmpty(lockFileCacheEnvironmentVariableName) ? null : Environment.GetEnvironmentVariable(lockFileCacheEnvironmentVariableName))
.OrIfNullOrEmpty((getDefaultLockFileCacheDir ?? GetDefaultLockFileDir)(Environment.GetEnvironmentVariable(
#if NET46
Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32S || Environment.OSVersion.Platform == PlatformID.Win32Windows || Environment.OSVersion.Platform == PlatformID.WinCE
#else
System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows)
#endif
? "USERPROFILE" : "HOME"))
)
.OrIfNullOrEmpty(null);
}
this._allLockFiles = new ConcurrentDictionary <ImmutableSortedSet <String>, ImmutableDictionary <ImmutableArray <NuGetVersion>, String> >();
this._lockFileFormat = new LockFileFormat();
this._clientPolicyContext = clientPolicyContext ?? ClientPolicyContext.GetClientPolicy(nugetSettings, nugetLogger);
}
