/// <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)); }