protected override void ExecuteTask() { if (ProjectFile == null && ProjectDir == null) throw new ValidationException("Either project or project-dir must be set on <nuget-get-dependencies />."); string dir = SolutionDir.FullName; _fileSystem = new PhysicalFileSystem(dir); string projectDir = ProjectFile == null ? ProjectDir.FullName : ProjectFile.Directory.FullName; RepositoryFactory = new PackageRepositoryFactory(); SourceProvider = new PackageSourceProvider(new Settings(_fileSystem)); var packagesConfigFiles = Directory.GetFiles(projectDir, Constants.PackageReferenceFile, SearchOption.AllDirectories); var project = packagesConfigFiles.Select(GetProject) .Where(p => p.Project != null) .SingleOrDefault(); if (project == null) { throw new BuildException("No project found", Location); } string repositoryPath = GetRepositoryPathFromSolution(dir); IPackageRepository sourceRepository = AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source); var references = GetReferences(project.PackagesConfigPath, project.Project, repositoryPath, sourceRepository); var deps = new NuGetDependencies { Dependencies = references.Select(GetDependency).ToArray() }; Project.DataTypeReferences.Add(ReferenceId, deps); Log(Level.Info, "Found {0} dependencies", deps.Dependencies.Length); }
public NugetService(Solution solution) { //_defaultPackageSource = new PackageSource(NuGetConstants.DefaultFeedUrl); var factory = new PackageRepositoryFactory(); _remoteRepository = factory.CreateRepository(GalleryUrl); _localRepository = factory.CreateRepository(solution.PackagesFolder()); _sourceRepository = new AggregateRepository(new[] { _remoteRepository, _localRepository }); _fileSystem = new PhysicalFileSystem(solution.PackagesFolder()); _pathResolver = new DefaultPackagePathResolver(_fileSystem); _console = new Console(); _packageManager = new PackageManager(_sourceRepository, _pathResolver, _fileSystem, _localRepository){ Logger = _console }; _packages = new Cache<NugetDependency, IPackage>(dep => { Install(dep); return _sourceRepository.FindPackage(dep.Name, dep.Version); }); }
/// <summary> /// Deletes all files from a package /// </summary> /// <param name="installed">Insyalled package</param> /// <param name="repositories">Repositories where to find the package</param> private void DeleteFiles(PackageInfo installed, ICollection<string> repositories) { Logger.Log("Deleting installed files... "); var factory = new PackageRepositoryFactory(); IPackage package; var globalRepo = new AggregateRepository(factory, repositories, true); package = globalRepo.FindPackage(installed.Name, SemanticVersion.Parse(installed.Version), true, true); if (package == null) { throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", installed.Name, installed.Version)); } var fylesystem = new PhysicalFileSystem(installed.InstallationDirectory); fylesystem.DeleteFiles(package.GetFiles(), installed.InstallationDirectory); File.Delete(Path.Combine(installed.InstallationDirectory, installed.Name + "." + installed.Version + ".nupkg")); foreach (var config in Directory.GetFiles(installed.InstallationDirectory, "*.config")) { File.Delete(config); } Logger.Log("Installed files deleted"); }
public NugetStore(string rootDirectory, string configFile = DefaultConfig, string overrideFile = OverrideConfig) { if (rootDirectory == null) throw new ArgumentNullException(nameof(rootDirectory)); if (configFile == null) throw new ArgumentNullException(nameof(configFile)); if (overrideFile == null) throw new ArgumentNullException(nameof(overrideFile)); // First try the override file with custom settings var configFileName = overrideFile; var configFilePath = Path.Combine(rootDirectory, configFileName); if (!File.Exists(configFilePath)) { // Override file does not exist, fallback to default config file configFileName = configFile; configFilePath = Path.Combine(rootDirectory, configFileName); if (!File.Exists(configFilePath)) { throw new ArgumentException($"Invalid installation. Configuration file [{configFile}] not found", nameof(configFile)); } } rootFileSystem = new PhysicalFileSystem(rootDirectory); Settings = NuGet.Settings.LoadDefaultSettings(rootFileSystem, configFileName, null); string installPath = Settings.GetRepositoryPath(); packagesFileSystem = new PhysicalFileSystem(installPath); packageSourceProvider = new PackageSourceProvider(Settings); repositoryFactory = new PackageRepositoryFactory(); SourceRepository = packageSourceProvider.CreateAggregateRepository(repositoryFactory, true); pathResolver = new DefaultPackagePathResolver(packagesFileSystem); Manager = new PackageManager(SourceRepository, pathResolver, packagesFileSystem); var mainPackageList = Settings.GetConfigValue(MainPackagesKey); if (string.IsNullOrWhiteSpace(mainPackageList)) { throw new InvalidOperationException($"Invalid configuration. Expecting [{MainPackagesKey}] in config"); } MainPackageIds = mainPackageList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); VSIXPluginId = Settings.GetConfigValue(VsixPluginKey); if (string.IsNullOrWhiteSpace(VSIXPluginId)) { throw new InvalidOperationException($"Invalid configuration. Expecting [{VsixPluginKey}] in config"); } RepositoryPath = Settings.GetConfigValue(RepositoryPathKey); if (string.IsNullOrWhiteSpace(RepositoryPath)) { RepositoryPath = DefaultGamePackagesDirectory; } // Setup NugetCachePath in the cache folder Environment.SetEnvironmentVariable("NuGetCachePath", Path.Combine(rootDirectory, "Cache", RepositoryPath)); }
protected override void ExecuteTask() { string dir = SolutionDir.FullName; _fileSystem = new PhysicalFileSystem(dir); RepositoryFactory = new PackageRepositoryFactory(); SourceProvider = new PackageSourceProvider(new Settings(_fileSystem)); UpdateAllPackages(dir); }
/// <summary> /// Searches all available versions of a package in a list of repostiories /// </summary> /// <param name="repositories">Repositories to search</param> /// <param name="packageName">Pacakge identifier</param> /// <returns>List of available versions</returns> public static ICollection<string> Search(ICollection<string> repositories, string packageName) { var factory = new PackageRepositoryFactory(); var globalRepo = new AggregateRepository(factory, repositories.Distinct(), true); var packages = globalRepo.FindPackagesById(packageName); return packages.Select(x => x.Version) .OrderByDescending(x => x) .Select(x => x.ToString()) .ToList() .Distinct().ToList() ; }
public int Count(string url, NetworkCredential credential) { var uri = new Uri(url); TestCredentialProvider.Instance.Credentials.Add(uri, credential); try { var repository = new PackageRepositoryFactory().CreateRepository(url); return repository.GetPackages().Count(); } finally { TestCredentialProvider.Instance.Credentials.Remove(uri); } }
public static Stream DownloadDacpac(string packageName, string version, string repository) { var factory = new PackageRepositoryFactory(); IPackage package; var globalRepo = new AggregateRepository(factory,new string[] { repository }, true); package = globalRepo.FindPackage(packageName, SemanticVersion.Parse(version), true, true); var files = package.GetFiles(); return files.Single(x => x.Path.EndsWith(".dacpac")).GetStream(); }
public AddInRepository(params AddInSource[] sources) { List<PackageSource> packageSources = new List<PackageSource>(); foreach (AddInSource source in sources) { PackageSource packageSource = new PackageSource(source.Source, source.Name, isEnabled: true, isOfficial: source.IsOfficial); packageSources.Add(packageSource); } PackageSourceProvider packageSourceProvider = new PackageSourceProvider(new NullSettings(), packageSources); IPackageRepositoryFactory packageRepositoryFactory = new PackageRepositoryFactory(); // TODO probably turn this off and report proper errors this._repository = packageSourceProvider.GetAggregate(packageRepositoryFactory, ignoreFailingRepositories: true); }
protected override void ExecuteTask() { string dir = SolutionDir.FullName; string repositoryPath = GetRepositoryPathFromSolution(dir); _fileSystem = new PhysicalFileSystem(dir); RepositoryFactory = new PackageRepositoryFactory(); SourceProvider = new PackageSourceProvider(new Settings(_fileSystem)); var repo = RepositoryFactory.CreateRepository(repositoryPath); Log(Level.Debug, "Repo: {0}, Count: {1}", repo.Source, repo.GetPackages().Count()); var fw = VersionUtility.ParseFrameworkName(Framework); List<string> files = new List<string>(), references = new List<string>(); foreach (var deps in Dependencies) { foreach (var dep in deps.Dependencies) { var package = repo.FindPackage(dep.Id, dep.VersionSpec, !String.IsNullOrWhiteSpace(dep.VersionSpec.MinVersion.SpecialVersion), false); if (package == null) package = repo.FindPackage(dep.Id, dep.VersionSpec, true, false); if (package == null) package = repo.FindPackage(dep.Id, dep.VersionSpec, true, true); if (package == null) throw new BuildException(String.Format("Can't find package {0} with min version {1}", dep.Id, dep.MinVersion), Location); string pkgPath = Path.Combine(repositoryPath, package.Id + "." + package.Version); var package_files = package.GetLibFiles().ToList(); IEnumerable<IPackageFile> compatible_files; Log(Level.Debug, "Found package {0} with {1} file(s) - {2}", package.Id, package_files.Count, package.GetType()); if (!VersionUtility.TryGetCompatibleItems(fw, package_files, out compatible_files)) throw new BuildException("Couldn't get compatible files."); foreach (var f in compatible_files) { var extension = Path.GetExtension(f.Path); var path = Path.Combine(pkgPath, f.Path); Log(Level.Debug, " - Found compatible file {1} ({0}) - {2}", f.Path, f.EffectivePath, path); if (extension == ".dll" || extension == ".exe") references.Add(path); files.Add(path); } } } if (FilesId != null) { PatternSet ps = new PatternSet(); ps.Include.AddRange(files.Select(MakePattern).ToArray()); Project.DataTypeReferences.Add(FilesId, ps); } if (ReferencesId != null) { PatternSet ps = new PatternSet(); ps.Include.AddRange(references.Select(MakePattern).ToArray()); Project.DataTypeReferences.Add(ReferencesId, ps); } Log(Level.Info, "Found {0} file(s) and {1} reference(s)", files.Count, references.Count); }
private async Task Initialize() { var listEndpoints = await GetListEndpointsAsync(_sourceProvider).ConfigureAwait(false); var repositoryFactory = new PackageRepositoryFactory(); var repositories = listEndpoints .Select(s => repositoryFactory.CreateRepository(s)) .ToList(); _repository = new AggregateRepository(repositories); }
/// <summary> /// Downloads the specified package and installs it in the configured folder /// </summary> /// <param name="info">Pacakge informations</param> private void DownloadPackage(PackageInfo info, ICollection<string> repositories) { Logger.Log(String.Format("Downloading package for {0} version {1} ... ", info.Name, info.Version)); var factory = new PackageRepositoryFactory(); IPackage package; var globalRepo = new AggregateRepository(factory, repositories, true); package = globalRepo.FindPackage(info.Name, SemanticVersion.Parse(info.Version), true, true); if (package == null) { throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", info.Name, info.Version)); } var manager = new PackageManager( globalRepo, new CustomPathResolver() { BasePath = info.InstallationDirectory }, new OverWritingPhysicalFilesystem(info.InstallationDirectory)); manager.InstallPackage(package, false, true); Logger.Log(String.Format("Package for {0} version {1} downloaded ... ", info.Name, info.Version)); }
public static IPackageRepository CreateRepository() { IPackageRepositoryFactory factory = new PackageRepositoryFactory(); IPackageRepository repository = factory.CreateRepository(new PackageSource("https://packages.nuget.org/v1/FeedService.svc/", "NuGet.org")); return repository; }
/// <summary> /// Checks for package updates /// </summary> /// <returns> /// The list of operations (if any) that should be applied to the /// current package or its dependents to bring it up to date /// </returns> private IList<PackageOperation> ListOperations() { var sourceRepo = new PackageRepositoryFactory().CreateRepository(this.Source); var localRepo = new PackageRepositoryFactory().CreateRepository(this.RepositoryRoot); var targetFramework = VersionUtility.ParseFrameworkName(this.TargetFramework); // locate the current version of the package in the source repository var pkg = PackageHelper.ResolvePackage( sourceRepo, localRepo, this.PackageID, null, false ); // walk the package, and emit any update operations var walker = new UpdateWalker( localRepo, sourceRepo, new DependentsWalker(localRepo, targetFramework), NullConstraintProvider.Instance, targetFramework, new Logger(), true, false ); return walker.ResolveOperations(pkg).ToList(); }