/// <summary>
/// Determines the remote repository to be used based on the state of the solution and the Source parameter
/// </summary>
private IPackageRepository GetRemoteRepository()
{
if (!String.IsNullOrEmpty(Source))
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(Source);
// If a Source parameter is explicitly specified, use it
return(_repositoryFactory.CreateRepository(Source));
}
else if (Recent.IsPresent)
{
return(_recentPackagesRepository);
}
else if (SolutionManager.IsSolutionOpen)
{
_hasConnectedToHttpSource |= IsHttpSource(_packageSourceProvider);
// If the solution is open, retrieve the cached repository instance
return(PackageManager.SourceRepository);
}
else if (_packageSourceProvider.ActivePackageSource != null)
{
_hasConnectedToHttpSource |= IsHttpSource(_packageSourceProvider);
// No solution available. Use the repository Url to create a new repository
return(_repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource));
}
else
{
// No active source has been specified.
throw new InvalidOperationException(Resources.Cmdlet_NoActivePackageSource);
}
}
public static IPackageRepository Create(IPackageRepositoryFactory factory, IList <PackageSource> sources, bool ignoreFailingRepositories)
{
if (sources.Count == 0)
{
return(null);
}
if (sources.Count == 1)
{
return(factory.CreateRepository(sources[0].Source));
}
Func <string, IPackageRepository> createRepository = new Func <string, IPackageRepository>(factory.CreateRepository);
if (ignoreFailingRepositories)
{
createRepository = delegate(string source) {
try
{
return(factory.CreateRepository(source));
}
catch (InvalidOperationException)
{
return(null);
}
};
}
AggregateRepository repository1 = new AggregateRepository(from source in sources
let repository = createRepository(source.Source)
where repository != null
select repository);
repository1.IgnoreFailingRepositories = ignoreFailingRepositories;
return(repository1);
}
/// <summary>
/// Create a package repository from the source by trying to resolve relative paths.
/// </summary>
protected SourceRepository CreateRepositoryFromSource(string source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
UriFormatException uriException = null;
string url = _packageSourceProvider.ResolveSource(source);
try
{
IPackageRepository repository = _repositoryFactory.CreateRepository(url);
}
catch (UriFormatException ex)
{
// if the source is relative path, it can result in invalid uri exception
uriException = ex;
}
Uri uri;
if (uriException != null)
{
// if it's not an absolute path, treat it as relative path
if (Uri.TryCreate(source, UriKind.Relative, out uri))
{
string outputPath;
bool? exists;
string errorMessage;
// translate relative path to absolute path
if (TryTranslatePSPath(source, out outputPath, out exists, out errorMessage) && exists == true)
{
source = outputPath;
url = _packageSourceProvider.ResolveSource(outputPath);
}
}
}
try
{
IPackageRepository repository = _repositoryFactory.CreateRepository(url);
PackageSource packageSource = new PackageSource(source, url);
var sourceRepo = new AutoDetectSourceRepository(packageSource, PSCommandsUserAgentClient, _repositoryFactory);
return(sourceRepo);
}
catch (Exception ex)
{
// if this is not a valid relative path either,
// we rethrow the UriFormatException that we caught earlier.
if (uriException != null)
{
throw uriException;
}
else
{
throw ex;
}
}
}
/// <summary>
/// Create a package repository from the source by trying to resolve relative paths.
/// </summary>
protected IPackageRepository CreateRepositoryFromSource(IPackageRepositoryFactory repositoryFactory, IPackageSourceProvider sourceProvider, string source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
UriFormatException uriException = null;
string resolvedSource = sourceProvider.ResolveSource(source);
try
{
IPackageRepository repository = repositoryFactory.CreateRepository(resolvedSource);
if (repository != null)
{
return(repository);
}
}
catch (UriFormatException ex)
{
// if the source is relative path, it can result in invalid uri exception
uriException = ex;
}
Uri uri;
// if it's not an absolute path, treat it as relative path
if (Uri.TryCreate(source, UriKind.Relative, out uri))
{
string outputPath;
bool? exists;
string errorMessage;
// translate relative path to absolute path
if (TryTranslatePSPath(source, out outputPath, out exists, out errorMessage) && exists == true)
{
return(repositoryFactory.CreateRepository(outputPath));
}
else
{
return(repositoryFactory.CreateRepository(source));
}
}
else
{
// if this is not a valid relative path either,
// we rethrow the UriFormatException that we caught earlier.
if (uriException != null)
{
throw uriException;
}
}
return(null);
}
public AggregateRepository(IPackageRepositoryFactory repositoryFactory, IEnumerable <string> packageSources, bool ignoreFailingRepositories)
{
this._failingRepositories = new ConcurrentBag <IPackageRepository>();
this.IgnoreFailingRepositories = ignoreFailingRepositories;
Func <string, IPackageRepository> createRepository = new Func <string, IPackageRepository>(repositoryFactory.CreateRepository);
if (ignoreFailingRepositories)
{
createRepository = delegate(string source) {
try
{
return(repositoryFactory.CreateRepository(source));
}
catch
{
return(null);
}
};
}
this._repositories = (from source in packageSources
let repository = createRepository(source)
where repository != null
select repository).ToArray <IPackageRepository>();
Func <IPackageRepository, bool> supportsPrereleasePackages = this.Wrap <bool>(r => r.SupportsPrereleasePackages, true);
this._supportsPrereleasePackages = new Lazy <bool>(() => Enumerable.All <IPackageRepository>(this._repositories, supportsPrereleasePackages));
}
/// <summary>
/// Determines the remote repository to be used based on the state of the solution and the Source parameter
/// </summary>
private IPackageRepository GetRemoteRepository()
{
IPackageRepository repository;
if (!String.IsNullOrEmpty(Source))
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(Source);
// If a Source parameter is explicitly specified, use it
repository = CreateRepositoryFromSource(_repositoryFactory, _packageSourceProvider, Source);
}
else if (SolutionManager.IsSolutionOpen)
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(_packageSourceProvider);
// If the solution is open, retrieve the cached repository instance
repository = PackageManager.SourceRepository;
}
else if (_packageSourceProvider.ActivePackageSource != null)
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(_packageSourceProvider);
// No solution available. Use the repository Url to create a new repository
repository = _repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource.Source);
}
else
{
// No active source has been specified.
throw new InvalidOperationException(Resources.Cmdlet_NoActivePackageSource);
}
if (IsRepositoryUsedForSearch(repository))
{
repository = new AggregateRepository(new [] { repository });
}
return(repository);
}
public PackageDownloadingService(IAgentSettingsManager agentSettingsManager,
IRetrievePackageQuery allPackagesQuery,
ILocalPackageCache agentCache,
IAgentConfigurationManager agentConfigurationManager,
ILogger logger,
IHubCommunicator hubCommunicator,
IInstalledPackageArchive installCache,
IPackageRepositoryFactory packageRepositoryFactory,
IPackagesList allPackagesList,
ICurrentlyDownloadingList currentlyDownloadingList,
CompletedInstallationTaskList installationResults,
IAgentWatchList watchList,
IInstallationManager installationManager,INotificationService notificationService)
{
_settingsManager = agentSettingsManager;
AllPackagesQuery = allPackagesQuery;
AgentCache = agentCache;
_agentConfigurationManager = agentConfigurationManager;
_logger = logger;
_hubCommunicator = hubCommunicator;
_installCache = installCache;
_packageRepository = packageRepositoryFactory.CreateRepository(agentSettingsManager.Settings.NuGetRepository);
_allPackagesList = allPackagesList;
_currentlyDownloadingList = currentlyDownloadingList;
_installationResults = installationResults;
_watchList = watchList;
_installationManager = installationManager;
_notificationService = notificationService;
TimedTask = new TimedSingleExecutionTask(agentSettingsManager.Settings.PackageSyncIntervalMs, FetchPackages,
_logger);
}
public static IPackageRepository GetAggregate(this IPackageSourceProvider provider, IPackageRepositoryFactory factory, bool ignoreFailingRepositories, IEnumerable<string> feeds)
{
Func<string, IPackageRepository> createRepository = factory.CreateRepository;
if (ignoreFailingRepositories)
{
createRepository = (source) =>
{
try
{
return factory.CreateRepository(source);
}
catch (InvalidOperationException)
{
return null;
}
};
}
var repositories = (from item in feeds
let repository = createRepository(provider.ResolveSource(item))
where repository != null
select repository).ToArray();
return new AggregateRepository(repositories) { IgnoreFailingRepositories = ignoreFailingRepositories };
}
public FeedVerificationResult VerifyFeed(string source, bool authenticateIfRequired = true)
{
var result = FeedVerificationResult.Valid;
Log.Debug("Verifying feed '{0}'", source);
using (ScopeManager <AuthenticationScope> .GetScopeManager(source.GetSafeScopeName(), () => new AuthenticationScope(authenticateIfRequired)))
{
try
{
var repository = _packageRepositoryFactory.CreateRepository(source);
repository.GetPackages().Take(1).Count();
}
catch (WebException ex)
{
result = HandleWebException(ex, source);
}
catch (UriFormatException ex)
{
Log.Debug(ex, "Failed to verify feed '{0}', a UriFormatException occurred", source);
result = FeedVerificationResult.Invalid;
}
catch (Exception ex)
{
Log.Debug(ex, "Failed to verify feed '{0}'", source);
result = FeedVerificationResult.Invalid;
}
}
Log.Debug("Verified feed '{0}', result is '{1}'", source, result);
return(result);
}
public static IPackageRepository GetAggregate(this IPackageSourceProvider provider, IPackageRepositoryFactory factory, bool ignoreFailingRepositories, IEnumerable <string> feeds)
{
Func <string, IPackageRepository> createRepository = factory.CreateRepository;
if (ignoreFailingRepositories)
{
createRepository = (source) =>
{
try
{
return(factory.CreateRepository(source));
}
catch (InvalidOperationException)
{
return(null);
}
};
}
var repositories = (from item in feeds
let repository = createRepository(provider.ResolveSource(item))
where repository != null
select repository).ToArray();
return(new AggregateRepository(repositories)
{
IgnoreFailingRepositories = ignoreFailingRepositories
});
}
public AggregateRepository(IPackageRepositoryFactory repositoryFactory, IEnumerable <string> packageSources, bool ignoreFailingRepositories)
{
IgnoreFailingRepositories = ignoreFailingRepositories;
Func <string, IPackageRepository> createRepository = repositoryFactory.CreateRepository;
if (ignoreFailingRepositories)
{
createRepository = (source) =>
{
try
{
return(repositoryFactory.CreateRepository(source));
}
catch
{
return(null);
}
};
}
_repositories = (from source in packageSources
let repository = createRepository(source)
where repository != null
select repository).ToArray();
Func <IPackageRepository, bool> supportsPrereleasePackages = Wrap(r => r.SupportsPrereleasePackages, defaultValue: true);
_supportsPrereleasePackages = new Lazy <bool>(() => _repositories.All(supportsPrereleasePackages));
}
internal IPackageRepository GetActiveRepository()
{
if (_packageSourceProvider.ActivePackageSource == null)
{
return(null);
}
return(_repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource.Source));
}
private IPackageRepository CreatePackageRestoreRepository()
{
var activeSource = _packageSourceProvider.ActivePackageSource;
if (activeSource == null)
{
return(_packageSourceProvider.CreateAggregateRepository(_packageRepositoryFactory, ignoreFailingRepositories: true));
}
IPackageRepository activeRepository = _packageRepositoryFactory.CreateRepository(activeSource.Source);
if (AggregatePackageSource.IsAggregate(activeSource))
{
return(activeRepository);
}
return(_packageSourceProvider.CreatePriorityPackageRepository(_packageRepositoryFactory, activeRepository));
}
/// <summary>
/// Determines the repository to be used based on the Source parameter
/// </summary>
private IPackageRepository GetRepository()
{
if (!String.IsNullOrEmpty(Source))
{
// If a Source parameter is explicitly specified, use it
return(_repositoryFactory.CreateRepository(Source));
}
else if (_packageSourceProvider.ActivePackageSource != null)
{
// No Source available. Use the active package source to create a new repository
return(_repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource));
}
else
{
// No active source has been specified.
throw new InvalidOperationException(Resources.Cmdlet_NoActivePackageSource);
}
}
protected internal override IVsPackageManager GetActivePackageManager()
{
if (_recentPackageManager == null)
{
var repository = _packageRepositoryFactory.CreateRepository(_aggregateSource);
_recentPackageManager = _packageManagerFactory.CreatePackageManager(repository);
}
return(_recentPackageManager);
}
public static IPackageRepository Create(
IPackageRepositoryFactory factory,
IList <PackageSource> sources,
bool ignoreFailingRepositories)
{
if (sources.Count == 0)
{
return(null);
}
if (sources.Count == 1)
{
// optimization: if there is only one package source, create a direct repository out of it.
return(factory.CreateRepository(sources[0].Source));
}
Func <string, IPackageRepository> createRepository = factory.CreateRepository;
if (ignoreFailingRepositories)
{
createRepository = (source) =>
{
try
{
return(factory.CreateRepository(source));
}
catch (InvalidOperationException)
{
return(null);
}
};
}
var repositories = from source in sources
let repository = createRepository(source.Source)
where repository != null
select repository;
return(new AggregateRepository(repositories)
{
IgnoreFailingRepositories = ignoreFailingRepositories
});
}
internal void InstallPackage(string source, Project project, string packageId, SemanticVersion version, bool ignoreDependencies)
{
if (String.IsNullOrEmpty(source))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "source");
}
IPackageRepository repository = _repositoryFactory.CreateRepository(source);
InstallPackage(repository, project, packageId, version, ignoreDependencies, skipAssemblyReferences: false);
}
public void InstallPackage(string source, Project project, string packageId, Version version, bool ignoreDependencies)
{
if (String.IsNullOrEmpty(source))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "source");
}
IPackageRepository repository = _repositoryFactory.CreateRepository(new PackageSource(source));
InstallPackage(repository, project, packageId, version, ignoreDependencies);
}
internal void InstallPackage(string source, Project project, string packageId, SemanticVersion version, bool ignoreDependencies)
{
if (String.IsNullOrEmpty(source))
{
// if source is null or empty, we fall back to aggregate package source
source = AggregatePackageSource.Instance.Source;
}
IPackageRepository repository = _repositoryFactory.CreateRepository(source);
InstallPackage(repository, project, packageId, version, ignoreDependencies, skipAssemblyReferences: false);
}
public IUpdateCheck CheckForUpdate()
{
var repository = _packageRepositoryFactory.CreateRepository(_packageSource);
var latestPackage = repository.FindPackage(_appPackageId);
if (latestPackage == null || CurrentVersion >= latestPackage.Version)
{
return(new UpdateNotFound());
}
return(new UpdateFound(latestPackage));
}
protected virtual IPackageRepository GetPackageRepository()
{
if (!String.IsNullOrEmpty(Source))
{
return(CreateRepositoryFromSource(_repositoryFactory, _packageSourceProvider, Source));
}
if (_packageSourceProvider.ActivePackageSource != null)
{
return(_repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource.Source));
}
throw new InvalidOperationException(Resources.Cmdlet_NoActivePackageSource);
}
private static IPackageRepository CreateRepository(IPackageRepositoryFactory repositoryFactory, PackageSource packageSource)
{
IPackageRepository packageRepository = repositoryFactory.CreateRepository(packageSource);
var httpClientEvents = packageRepository as IHttpClientEvents;
if (httpClientEvents != null) {
httpClientEvents.SendingRequest += (sender, args) => {
string userAgent = HttpUtility.CreateUserAgentString(UserAgentClient);
HttpUtility.SetUserAgent(args.Request, userAgent);
};
}
return packageRepository;
}
public PackageRepositoryBrowser(ISourceRepositoryProvider sourceRepositoryProvider, IPackageRepositoryFactory packageRepositoryFactory)
{
if (sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
if (packageRepositoryFactory == null)
{
throw new ArgumentNullException("packageRepositoryFactory");
}
this.repositoryConfigurations = sourceRepositoryProvider.GetRepositoryConfigurations().ToArray();
this.repositories = this.repositoryConfigurations.Select(r => packageRepositoryFactory.CreateRepository(r.Url.ToString())).ToArray();
}
private static IPackageRepository CreateRepository(IPackageRepositoryFactory repositoryFactory, PackageSource packageSource)
{
IPackageRepository packageRepository = repositoryFactory.CreateRepository(packageSource);
var httpClientEvents = packageRepository as IHttpClientEvents;
if (httpClientEvents != null)
{
httpClientEvents.SendingRequest += (sender, args) => {
string userAgent = HttpUtility.CreateUserAgentString(UserAgentClient);
HttpUtility.SetUserAgent(args.Request, userAgent);
};
}
return(packageRepository);
}
public IPackage GetPackage(string appName, SemanticVersion version, string repoLocation)
{
var repo = _packageRepositoryFactory.CreateRepository(repoLocation);
try
{
return(repo.GetPackages()
.ToList()
.LastOrDefault(x => x.Id == appName && x.Version == version));
}
catch (Exception ex)
{
_log.Error("Could not get packages", ex);
return(null);
}
}
internal void SelfUpdate(string exePath, SemanticVersion version)
{
Console.WriteLine(NuGetResources.UpdateCommandCheckingForUpdates, NuGetConstants.DefaultFeedUrl);
// Get the nuget command line package from the specified repository
IPackageRepository packageRepository = _repositoryFactory.CreateRepository(NuGetConstants.DefaultFeedUrl);
IPackage package = packageRepository.FindPackage(NuGetCommandLinePackageId);
// We didn't find it so complain
if (package == null)
{
throw new CommandLineException(NuGetResources.UpdateCommandUnableToFindPackage, NuGetCommandLinePackageId);
}
Console.WriteLine(NuGetResources.UpdateCommandCurrentlyRunningNuGetExe, version);
// Check to see if an update is needed
if (version >= package.Version)
{
Console.WriteLine(NuGetResources.UpdateCommandNuGetUpToDate);
}
else
{
Console.WriteLine(NuGetResources.UpdateCommandUpdatingNuGet, package.Version);
// Get NuGet.exe file from the package
IPackageFile file = package.GetFiles().FirstOrDefault(f => Path.GetFileName(f.Path).Equals(NuGetExe, StringComparison.OrdinalIgnoreCase));
// If for some reason this package doesn't have NuGet.exe then we don't want to use it
if (file == null)
{
throw new CommandLineException(NuGetResources.UpdateCommandUnableToLocateNuGetExe);
}
// Get the exe path and move it to a temp file (NuGet.exe.old) so we can replace the running exe with the bits we got
// from the package repository
string renamedPath = exePath + ".old";
Move(exePath, renamedPath);
// Update the file
UpdateFile(exePath, file);
Console.WriteLine(NuGetResources.UpdateCommandUpdateSuccessful);
}
}
public IEnumerable <IPackage> GetLatestVersions(string repoLocation)
{
var repo = _packageRepositoryFactory.CreateRepository(repoLocation);
try
{
var all = repo.GetPackages()
.Where(x => x.IsLatestVersion)
.ToList()
.OrderBy(p => p.Id);
return(all);
}
catch (Exception ex)
{
_output.WriteLine("No packages could be found at {0}. Is the path or url correct?", repoLocation);
return(null);
}
}
internal void SelfUpdate(string exePath, SemanticVersion version)
{
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandCheckingForUpdates"), NuGetConstants.V2FeedUrl);
// Get the nuget command line package from the specified repository
IPackageRepository packageRepository = _repositoryFactory.CreateRepository(NuGetConstants.V2FeedUrl);
IPackage package = packageRepository.GetUpdates(
new [] { new PackageName(NuGetCommandLinePackageId, version) },
includePrerelease: true,
includeAllVersions: false,
targetFrameworks: null,
versionConstraints: null).FirstOrDefault();
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandCurrentlyRunningNuGetExe"), version);
// Check to see if an update is needed
if (package == null || version >= package.Version)
{
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandNuGetUpToDate"));
}
else
{
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandUpdatingNuGet"), package.Version);
// Get NuGet.exe file from the package
IPackageFile file = package.GetFiles().FirstOrDefault(f => Path.GetFileName(f.Path).Equals(NuGetExe, StringComparison.OrdinalIgnoreCase));
// If for some reason this package doesn't have NuGet.exe then we don't want to use it
if (file == null)
{
throw new CommandLineException(LocalizedResourceManager.GetString("UpdateCommandUnableToLocateNuGetExe"));
}
// Get the exe path and move it to a temp file (NuGet.exe.old) so we can replace the running exe with the bits we got
// from the package repository
string renamedPath = exePath + ".old";
Move(exePath, renamedPath);
// Update the file
UpdateFile(exePath, file);
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandUpdateSuccessful"));
}
}
private void LoadPackagesFromSettingsStore()
{
// find recent packages from the Aggregate repository
IPackageRepository aggregateRepository = _repositoryFactory.CreateRepository(_aggregatePackageSource);
// get the metadata of recent packages from registry
IEnumerable <IPersistencePackageMetadata> packagesMetadata = LoadPackageMetadataFromSettingsStore();
// find the packages based on metadata from the Aggregate repository based on Id only
IEnumerable <IPackage> newPackages = aggregateRepository.FindPackages(packagesMetadata.Select(p => p.Id));
// newPackages contains all versions of a package Id. Filter out the versions that we don't care.
IEnumerable <RecentPackage> filterPackages = FilterPackages(packagesMetadata, newPackages);
foreach (var p in filterPackages)
{
AddRecentPackage(p, false);
}
}
public IPackage GetLatestVersionOf(string appName, string repoLocation)
{
var repo = _packageRepositoryFactory.CreateRepository(repoLocation);
try
{
var all = repo.GetPackages()
.Where(x => x.Id == appName /* && x.IsLatestVersion*/)
.OrderByDescending(x => x.Version)
.ToList();
return(all.FirstOrDefault());
}
catch (Exception ex)
{
_log.Error("Could not get packages", ex);
return(null);
}
}
public FeedVerificationResult VerifyFeed(string source, bool authenticateIfRequired = true)
{
var result = FeedVerificationResult.Valid;
using (_authenticationSilencerService.AuthenticationRequiredScope(authenticateIfRequired))
{
try
{
var repository = _packageRepositoryFactory.CreateRepository(source);
var packagesCount = repository.GetPackages().Take(1).Count();
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.ProtocolError)
{
var response = ex.Response as HttpWebResponse;
if (response != null && response.StatusCode == HttpStatusCode.Unauthorized)
{
result = FeedVerificationResult.AuthenticationRequired;
}
else
{
result = FeedVerificationResult.Invalid;
}
}
else
{
result = FeedVerificationResult.Invalid;
}
}
catch (UriFormatException)
{
result = FeedVerificationResult.Invalid;
}
catch
{
result = FeedVerificationResult.Invalid;
}
}
return(result);
}
private IPackageRepository GetPackageRepository(PackageSource packageSource)
{
IPackageRepository repository;
if (!_repositoryCache.TryGetValue(packageSource, out repository))
{
repository = _repositoryFactory.CreateRepository(packageSource);
_repositoryCache.TryAdd(packageSource, repository);
// See if this repository provides progress
var progressProvider = repository as IProgressProvider;
if (progressProvider != null)
{
progressProvider.ProgressAvailable += OnProgressAvailable;
}
var httpEvents = repository as IHttpClientEvents;
if (httpEvents != null)
{
httpEvents.SendingRequest += OnSendingRequest;
}
}
return(repository);
}
private IPackageRepository GetPackageRepository(string source)
{
IPackageRepository repository;
if (!_repositoryCache.TryGetValue(source, out repository))
{
repository = _repositoryFactory.CreateRepository(source);
_repositoryCache.TryAdd(source, repository);
// See if this repository provides progress
var progressProvider = repository as IProgressProvider;
if (progressProvider != null)
{
progressProvider.ProgressAvailable += OnProgressAvailable;
}
var httpEvents = repository as IHttpClientEvents;
if (httpEvents != null)
{
SendingRequestEventManager.AddListener(httpEvents, this);
}
}
return(repository);
}
private async Task DetectVersionWhenNeccessary()
{
await _lock.WaitAsync();
try
{
if (_repo != null)
{
return;
}
bool r = await IsV3Async(_source);
if (r)
{
_repo = new V3SourceRepository(_source, _host);
return;
}
r = await IsV2Async(_source);
if (r)
{
_repo = new NuGet.Client.Interop.V2SourceRepository(
_source, _v2RepoFactory.CreateRepository(_source.Url), _host);
return;
}
throw new InvalidOperationException(
String.Format("source {0} is not available", _source.Url));
}
finally
{
_lock.Release();
}
}
public RetrieveNuGetPackageQuery(IPackageRepositoryFactory packageRepositoryFactory, FeedLocation feedLocation, ILogger logger)
{
_packageRepositoryFactory = packageRepositoryFactory;
_logger = logger;
_packageRepository = _packageRepositoryFactory.CreateRepository(feedLocation.Source);
}
public LazyRepository(IPackageRepositoryFactory factory, PackageSource source)
{
_repository = new Lazy<IPackageRepository>(() => factory.CreateRepository(source.Source));
}
