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); }); }
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); }
public void Initialize() { var path = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder); _repositoryUrls = GetRepositorySources(path); var remoteRepository = new AggregateRepository(PackageRepositoryFactory.Default, _repositoryUrls, true); _manager = new PackageManager(remoteRepository, path); }
/// <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 NugetInstallationProvider(IFileSystem fileSystem) { _fileSystem = fileSystem; var path = Path.Combine(fileSystem.CurrentDirectory, Constants.PackagesFolder); _repositoryUrls = GetRepositorySources(path); var remoteRepository = new AggregateRepository(PackageRepositoryFactory.Default, _repositoryUrls, true); _manager = new PackageManager(remoteRepository, path); }
internal static IEnumerable <IPackageRepository> Flatten(IEnumerable <IPackageRepository> repositories) => Enumerable.SelectMany <IPackageRepository, IPackageRepository>(repositories, delegate(IPackageRepository repository) { AggregateRepository repository2 = repository as AggregateRepository; if (repository2 != null) { return(repository2.Repositories.ToArray <IPackageRepository>()); } return(new IPackageRepository[] { repository }); });
public NugetStore(string rootDirectory, string configFile = DefaultConfig, string overrideFile = OverrideConfig) { if (rootDirectory == null) throw new ArgumentNullException("rootDirectory"); if (configFile == null) throw new ArgumentNullException("configFile"); if (overrideFile == null) throw new ArgumentNullException("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(String.Format("Invalid installation. Configuration file [{0}] not found", configFile), "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(); aggregateRepository = packageSourceProvider.CreateAggregateRepository(repositoryFactory, true); pathResolver = new DefaultPackagePathResolver(packagesFileSystem); manager = new PackageManager(aggregateRepository, pathResolver, packagesFileSystem); MainPackageId = Settings.GetConfigValue(MainPackageKey); if (string.IsNullOrWhiteSpace(MainPackageId)) { throw new InvalidOperationException(string.Format("Invalid configuration. Expecting [{0}] in config", MainPackageKey)); } VSIXPluginId = Settings.GetConfigValue(VsixPluginKey); if (string.IsNullOrWhiteSpace(VSIXPluginId)) { throw new InvalidOperationException(string.Format("Invalid configuration. Expecting [{0}] in config", VsixPluginKey)); } RepositoryPath = Settings.GetConfigValue(RepositoryPathKey); if (string.IsNullOrWhiteSpace(RepositoryPath)) { RepositoryPath = DefaultGamePackagesDirectory; } // Setup NugetCachePath in the cache folder Environment.SetEnvironmentVariable("NuGetCachePath", Path.Combine(rootDirectory, "Cache", RepositoryPath)); }
public static IPackageRepository CreatePriorityPackageRepository(this IPackageSourceProvider provider, IPackageRepositoryFactory factory, IPackageRepository primaryRepository) { PackageSource[] sources = (from s in provider.GetEnabledPackageSources() where !s.Source.Equals(primaryRepository.Source, StringComparison.OrdinalIgnoreCase) select s).ToArray <PackageSource>(); if (sources.Length == 0) { return(primaryRepository); } return(new PriorityPackageRepository(primaryRepository, AggregateRepository.Create(factory, sources, true))); }
/// <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 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(); }
/// <summary> /// Enumerates the installed <see cref="SolutionPackage" /> /// </summary> /// <returns> /// An enumeration of <see cref="SolutionPackage" />. /// </returns> public IEnumerable<SolutionPackage> Installed() { var solutions = SPFarm.Local.Solutions.ToList(); var repository = new AggregateRepository(this.solutionPackageSourceRepository.All().Where(source => source.IsEnabled).Select(source => PackageRepositoryFactory.Default.CreateRepository(source.Source))); var solutionPackageGroups = repository.QueryForAbsoluteLatestVersionOfSolutionPackages().ToList().GroupBy(package => package.Id); foreach (var solutionPackageGroup in solutionPackageGroups) { IPackage solutionPackage = solutionPackageGroup.FindByVersion(new VersionSpec(solutionPackageGroup.Max(p => p.Version))).First(); var solution = solutions.Find(s => s.Name.ToLower().Equals(solutionPackage.Id.ToLower())); if (solution != null) { yield return new SolutionPackage(solutionPackage, solution.GetVersion()); } } }
public NuGetDownloader(string nugetName, IEnumerable<string> repositories) { package = nugetName; var nugetCacheDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Cache"); var reposToUse = new List<IPackageRepository> { PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory) }; reposToUse.AddRange(repositories.ToList().Select(r => PackageRepositoryFactory.Default.CreateRepository(r))); var repo = new AggregateRepository(reposToUse); packageManager = new PackageManager(repo, "packages"); }
public static AggregateRepository CreateAggregateRepositoryFromSources(IPackageRepositoryFactory factory, IPackageSourceProvider sourceProvider, IEnumerable<string> sources) { AggregateRepository repository; if (sources != null && sources.Any()) { var repositories = sources.Select(s => sourceProvider.ResolveSource(s)) .Select(factory.CreateRepository) .ToList(); repository = new AggregateRepository(repositories); } else { repository = sourceProvider.GetAggregate(factory, ignoreFailingRepositories: true); } return repository; }
public static IPackageRepository CreatePriorityPackageRepository( this IPackageSourceProvider provider, IPackageRepositoryFactory factory, IPackageRepository primaryRepository) { var nonActivePackageSources = provider.GetEnabledPackageSources() .Where(s => !s.Source.Equals(primaryRepository.Source, StringComparison.OrdinalIgnoreCase)) .ToArray(); if (nonActivePackageSources.Length == 0) { return(primaryRepository); } var fallbackRepository = AggregateRepository.Create(factory, sources: nonActivePackageSources, ignoreFailingRepositories: true); return(new PriorityPackageRepository(primaryRepository, fallbackRepository)); }
public IPackageManager CreatePackageManager(IEnumerable<string> remoteSources, string packagesPath) { if (remoteSources == null) { throw new ArgumentNullException("remoteSources"); } if (!remoteSources.Any()) { throw new ArgumentException("Must provide at least one remote source"); } var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true); var pathResolver = new DefaultPackagePathResolver(packagesPath); var packageManagerFileSystem = new PhysicalFileSystem(packagesPath); return new PackageManager(sourceRepository: sourceRepo, pathResolver: pathResolver, fileSystem: packageManagerFileSystem); }
public IProjectManager CreateProjectManager(IEnumerable<string> remoteSources, string packagesPath, IProjectSystem project) { if(remoteSources == null) { throw new ArgumentNullException("remoteSources"); } if (!remoteSources.Any()) { throw new ArgumentException("Must provide at least one remote source"); } var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true); var pathResolver = new DefaultPackagePathResolver(packagesPath); var packagesConfigRepo = new PackageReferenceRepository(project, project.ProjectName, new SharedPackageRepository(packagesPath)); return new ProjectManager(sourceRepository: sourceRepo, pathResolver: pathResolver, localRepository: packagesConfigRepo, project: project); }
public NuGetDownloader(string nugetName, IEnumerable<string> repositories) { package = nugetName; var nugetCacheDirectory = Path.Combine(AzureEnvironment.GetTempPath(), "packages"); var reposToUse = new List<IPackageRepository> { PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory) }; if (!AzureEnvironment.IsRunningInCloud()) { reposToUse.Add(MachineCache.Default); } reposToUse.AddRange(repositories.ToList().Select(r => PackageRepositoryFactory.Default.CreateRepository(r))); var repo = new AggregateRepository(reposToUse); packageManager = new PackageManager(repo, /*"packages"*/nugetCacheDirectory); }
public static IPackageRepository GetRemoteRepository(ChocolateyConfiguration configuration, ILogger nugetLogger) { IEnumerable<string> sources = configuration.Sources.Split(new[] {";", ","}, StringSplitOptions.RemoveEmptyEntries); IList<IPackageRepository> repositories = new List<IPackageRepository>(); // ensure credentials can be grabbed from configuration HttpClient.DefaultCredentialProvider = new ChocolateyNugetCredentialProvider(configuration); foreach (var source in sources.or_empty_list_if_null()) { try { var uri = new Uri(source); if (uri.IsFile || uri.IsUnc) { repositories.Add(new ChocolateyLocalPackageRepository(uri.LocalPath)); } else { repositories.Add(new DataServicePackageRepository(new RedirectedHttpClient(uri))); } } catch (Exception) { repositories.Add(new ChocolateyLocalPackageRepository(source)); } } //todo well that didn't work on failing repos... grrr var repository = new AggregateRepository(repositories) {IgnoreFailingRepositories = true}; repository.ResolveDependenciesVertically = true; if (configuration.Debug) { repository.Logger = nugetLogger; } return repository; }
public void ApproveNServiceBus() { var packages = new[] { "4.6.4", "5.0.0-beta0004" }; var nugetCacheDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Cache"); var repo = new AggregateRepository(new[] { PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory), PackageRepositoryFactory.Default.CreateRepository("https://www.nuget.org/api/v2"), PackageRepositoryFactory.Default.CreateRepository("https://www.myget.org/F/particular/"), }); var packageManager = new PackageManager(repo, "packages"); foreach (var v in packages) { if (!Directory.Exists(Path.Combine("packages", "NServiceBus." + v))) packageManager.InstallPackage("NServiceBus", SemanticVersion.Parse(v)); } var file1 = Path.Combine("packages", "NServiceBus." + packages[0], "lib", "net40", "NServiceBus.Core.dll"); var file2 = Path.Combine("packages", "NServiceBus." + packages[1], "lib", "net45", "NServiceBus.Core.dll"); var engine = new ComparerEngine(); var diff = engine.CreateDiff(file1, file2); var stringBuilder = new StringWriter(); var formatter = new APIUpgradeToMarkdownFormatter(); formatter.WriteOut(diff, stringBuilder, new FormattingInfo(string.Empty, string.Empty)); Approvals.Verify(stringBuilder.ToString()); }
public IRepository GetUpdateAggeregateRepository() { return _repositoryCacheService.GetSerializableRepository(RepositoryName.All, "all", PackageOperationType.Update, () => { var packageSources = GetPackageSources(); var sourceRepository = new AggregateRepository(_repositoryFactory, packageSources.Select(x => x.Source), true); return new UpdateRepository(LocalNuGetRepository, sourceRepository); }, true); }
public static IPackageRepository GetRemoteRepository(ChocolateyConfiguration configuration, ILogger nugetLogger) { IEnumerable<string> sources = configuration.Sources.Split(new[] {";", ","}, StringSplitOptions.RemoveEmptyEntries); IList<IPackageRepository> repositories = new List<IPackageRepository>(); // ensure credentials can be grabbed from configuration HttpClient.DefaultCredentialProvider = new ChocolateyNugetCredentialProvider(configuration); HttpClient.DefaultCertificateProvider = new ChocolateyClientCertificateProvider(configuration); if (!string.IsNullOrWhiteSpace(configuration.Proxy.Location)) { "chocolatey".Log().Debug("Using proxy server '{0}'.".format_with(configuration.Proxy.Location)); var proxy = new WebProxy(configuration.Proxy.Location, true); if (!String.IsNullOrWhiteSpace(configuration.Proxy.User) && !String.IsNullOrWhiteSpace(configuration.Proxy.EncryptedPassword)) { proxy.Credentials = new NetworkCredential(configuration.Proxy.User, NugetEncryptionUtility.DecryptString(configuration.Proxy.EncryptedPassword)); } ProxyCache.Instance.Override(proxy); } var updatedSources = new StringBuilder(); foreach (var sourceValue in sources.or_empty_list_if_null()) { var source = sourceValue; if (configuration.MachineSources.Any(m => m.Name.is_equal_to(source))) { "chocolatey".Log().Debug("Switching source name {0} to actual source value.".format_with(sourceValue)); try { source = configuration.MachineSources.FirstOrDefault(m => m.Name.is_equal_to(source)).Key; } catch (Exception ex) { "chocolatey".Log().Warn("Attempted to use a source name {0} to get default source but failed:{1} {2}".format_with(sourceValue, Environment.NewLine, ex.Message)); } } updatedSources.AppendFormat("{0};", source); try { var uri = new Uri(source); if (uri.IsFile || uri.IsUnc) { repositories.Add(new ChocolateyLocalPackageRepository(uri.LocalPath)); } else { repositories.Add(new DataServicePackageRepository(new RedirectedHttpClient(uri))); } } catch (Exception) { repositories.Add(new ChocolateyLocalPackageRepository(source)); } } if (updatedSources.Length != 0) { configuration.Sources = updatedSources.Remove(updatedSources.Length - 1, 1).to_string(); } //todo well that didn't work on failing repos... grrr var repository = new AggregateRepository(repositories) {IgnoreFailingRepositories = true}; repository.ResolveDependenciesVertically = true; if (configuration.Debug) { repository.Logger = nugetLogger; } return repository; }
protected virtual IPackageRepository GetRepository() { var aggregateRepository = AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, (IEnumerable<string>)Source); var failingRepositories = aggregateRepository.IgnoreFailingRepositories; if (!NoCache) aggregateRepository = new AggregateRepository((IEnumerable<IPackageRepository>)new IPackageRepository[2] { CacheRepository, (IPackageRepository)aggregateRepository }) { IgnoreFailingRepositories = failingRepositories }; aggregateRepository.Logger = (ILogger)Console; return (IPackageRepository)aggregateRepository; }
/// <summary> /// </summary> private int Run(Assembly integrationAgentAssembly, string integrationAgentExeFileName, string integrationAgentExeDirectory, string[] args) { var parameters = Program.ParseArguments(args); var fileVersion = FileVersionInfo.GetVersionInfo(integrationAgentAssembly.Location).FileVersion; if (parameters.ShowVersion || parameters.ShowHelp) { Console.WriteLine("IntegrationAgent v" + fileVersion); } if (parameters.ShowHelp) { Program.ShowHelp(); } if (parameters.ShowVersion || parameters.ShowHelp) { return 0; } // Verify that assembly is signed and uses the correct key var traceWriter = Program.CreateTraceWriter(parameters.TraceLevel); traceWriter(TraceLevel.Verbose, "Checking assembly strong name."); if (!integrationAgentAssembly.HasValidStrongName()) { traceWriter(TraceLevel.Error, "Unsigned assembly!"); return 1; } traceWriter(TraceLevel.Verbose, "Verifying assembly signature."); if (!integrationAgentAssembly.PublicKeyTokenEqualsTo(Token.Bytes)) { traceWriter(TraceLevel.Error, "Invalid assembly!"); return 2; } // If no JSON config file name provided as paramter uses the application name traceWriter(TraceLevel.Verbose, "Looking for JSON config file."); var configFile = Path.Combine(integrationAgentExeDirectory, Path.GetFileNameWithoutExtension(integrationAgentExeFileName) + ".json"); if (!string.IsNullOrEmpty(parameters.Config)) { if (!parameters.Config.EndsWith(".json")) { parameters.Config = parameters.Config + ".json"; } configFile = Path.Combine(integrationAgentExeDirectory, parameters.Config); } // Check and reads the configuration file var configuration = new Configuration(); if (File.Exists(configFile)) { traceWriter(TraceLevel.Verbose, "Reading the JSON config file."); var configJson = File.ReadAllText(configFile); var jsonSerializer = new JavaScriptSerializer(); configuration = jsonSerializer.Deserialize<Configuration>(configJson) ?? configuration; traceWriter(TraceLevel.Verbose, "JSON config file loaded."); } // Merges config file and command line parameters. Command line paramters have precedence. configuration.package = parameters.Package ?? configuration.package; configuration.token = parameters.Token ?? configuration.token; configuration.repository = parameters.Repository ?? configuration.repository; configuration.repositoryUsername = parameters.RepositoryUsername ?? configuration.repositoryUsername; configuration.repositoryPassword = parameters.RepositoryPassword ?? configuration.repositoryPassword; traceWriter(TraceLevel.Verbose, "Checking input parameters."); if (string.IsNullOrWhiteSpace(configuration.package) && string.IsNullOrEmpty(configuration.token)) { traceWriter(TraceLevel.Error, "Invalid configuration!"); return 3; } // Initializes NuGet repositories traceWriter(TraceLevel.Verbose, "Initializing NuGet repositories."); var nugetRepository = new DataServicePackageRepository(new Uri(NuGetRepository)); var aggregateRepository = new AggregateRepository(new[] { nugetRepository }); if (Uri.IsWellFormedUriString(configuration.repository, UriKind.Absolute)) { if (!string.IsNullOrWhiteSpace(configuration.repositoryUsername) && !string.IsNullOrWhiteSpace(configuration.repositoryPassword)) { HttpClient.DefaultCredentialProvider = new NugetCredentialProvider( configuration.repositoryUsername, configuration.repositoryPassword); } var client = new HttpClient(new Uri(configuration.repository)); var customRepository = new DataServicePackageRepository(client); aggregateRepository = new AggregateRepository(new[] { customRepository, nugetRepository }); } // Perform auto-update if not disabled if (!parameters.DisableUpdates) { traceWriter(TraceLevel.Verbose, "Checking for self update."); var integrationAgentAssemblyName = integrationAgentAssembly.GetName(); var version = new SemanticVersion(integrationAgentAssemblyName.Version); var package = aggregateRepository .GetUpdates(new[] { new PackageName(integrationAgentAssemblyName.Name, version) }, includePrerelease: false, includeAllVersions: false) .OrderBy(p => p.Version) .LastOrDefault(); if (package != null && package.Version > version) { traceWriter(TraceLevel.Verbose, "Newer version found. Updating files."); var filename = Path.GetFileName(integrationAgentExeFileName); var file = package.GetFiles().FirstOrDefault(f => !string.IsNullOrEmpty(f.Path) && Path.GetFileName(f.Path).Equals(filename, StringComparison.OrdinalIgnoreCase)); if (file != null) { File.Delete(integrationAgentExeFileName + ".bak"); File.Move(integrationAgentExeFileName, integrationAgentExeFileName + ".bak"); using (Stream fromStream = file.GetStream(), toStream = File.Create(integrationAgentExeFileName)) { fromStream.CopyTo(toStream); } Process.Start(integrationAgentExeFileName, string.Join(" ", args) + " -disableupdates"); Environment.Exit(0); } } else { traceWriter(TraceLevel.Verbose, "Version is up to date."); } } // Install the package to run including its dependencies traceWriter(TraceLevel.Verbose, "Checking for execution package."); var packagesPath = Path.Combine(integrationAgentExeDirectory, "packages"); var remotePackage = aggregateRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault(); var localRepository = new SharedPackageRepository(packagesPath); if (!localRepository.Exists(remotePackage)) { traceWriter(TraceLevel.Verbose, "Execution package not found localy. Installing remote."); var packageManager = new PackageManager(aggregateRepository, packagesPath); packageManager.InstallPackage(remotePackage, ignoreDependencies: false, allowPrereleaseVersions: false); } var localPackage = localRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault(); if (localPackage == null) { traceWriter(TraceLevel.Error, "Package not found!"); return 4; } // Build a dictionary list of assemblies based on assembly fully qualified name for dynamically resolving from the loaded package traceWriter(TraceLevel.Verbose, "Resolving execution package dependencies."); var allAssemblies = localRepository .GetPackages() .ToArray() .SelectMany(p => p.AssemblyReferences.Select(a => { var path = Path.Combine(packagesPath, p.Id + "." + p.Version, a.Path); var aname = AssemblyName.GetAssemblyName(path); return new { key = aname.FullName, value = path }; })) .DistinctBy(i => i.key) .ToDictionary(i => i.key, i => i.value); AppDomain.CurrentDomain.AssemblyResolve += (sender, eventArgs) => { var aname = new AssemblyName(eventArgs.Name); if (allAssemblies.ContainsKey(aname.FullName)) { return Assembly.LoadFile(allAssemblies[aname.FullName]); } return null; }; // Run the package export delegate if found var assemblies = localPackage.AssemblyReferences.Select(a => new AssemblyCatalog(Path.Combine(packagesPath, localPackage.Id + "." + localPackage.Version, a.Path))); using (var catalog = new AggregateCatalog(assemblies)) using (var container = new CompositionContainer(catalog)) { traceWriter(TraceLevel.Verbose, "Resolving execution package entry point."); container.SatisfyImportsOnce(this); if (this.RunAssembly == null) { traceWriter(TraceLevel.Error, "Execution package extry point not found!"); return 5; } traceWriter(TraceLevel.Verbose, "Invoking execution package extry point."); this.RunAssembly(configuration.token, traceWriter); traceWriter(TraceLevel.Verbose, "Execution package finished successfully."); return 0; } }
public static IPackageRepository GetRemoteRepository(ChocolateyConfiguration configuration, ILogger nugetLogger) { IEnumerable<string> sources = configuration.Sources.Split(new[] {";", ","}, StringSplitOptions.RemoveEmptyEntries); IList<IPackageRepository> repositories = new List<IPackageRepository>(); // ensure credentials can be grabbed from configuration HttpClient.DefaultCredentialProvider = new ChocolateyNugetCredentialProvider(configuration); if (!string.IsNullOrWhiteSpace(configuration.Proxy.Location)) { "chocolatey".Log().Debug("Using proxy server '{0}'.".format_with(configuration.Proxy.Location)); var proxy = new WebProxy(configuration.Proxy.Location, true); if (!String.IsNullOrWhiteSpace(configuration.Proxy.User) && !String.IsNullOrWhiteSpace(configuration.Proxy.EncryptedPassword)) { proxy.Credentials = new NetworkCredential(configuration.Proxy.User, NugetEncryptionUtility.DecryptString(configuration.Proxy.EncryptedPassword)); } ProxyCache.Instance.Override(proxy); } foreach (var source in sources.or_empty_list_if_null()) { try { var uri = new Uri(source); if (uri.IsFile || uri.IsUnc) { repositories.Add(new ChocolateyLocalPackageRepository(uri.LocalPath)); } else { repositories.Add(new DataServicePackageRepository(new RedirectedHttpClient(uri))); } } catch (Exception) { repositories.Add(new ChocolateyLocalPackageRepository(source)); } } //todo well that didn't work on failing repos... grrr var repository = new AggregateRepository(repositories) {IgnoreFailingRepositories = true}; repository.ResolveDependenciesVertically = true; if (configuration.Debug) { repository.Logger = nugetLogger; } return repository; }
public void Logger_SetLoggerWhenSourceRepositoryIsAggregateRepository_LoggerOnAggregateRepositoryIsSet () { var aggregateRepository = new AggregateRepository (new FakePackageRepository [0]); CreateProject (aggregateRepository); var expectedLogger = new FakeLogger (); project.Logger = expectedLogger; Assert.AreEqual (expectedLogger, aggregateRepository.Logger); }
/// <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)); }
protected virtual IPackageRepository GetAvailableRepository() { var repositories = new List<IPackageRepository> { PackageRepositoryFactory.Default.CreateRepository(AvailableRepository) }; var packageSources = FileUtil.MapPath("/sitecore/shell/client/Applications/Pathfinder/PackageSources.txt"); if (File.Exists(packageSources)) { var sources = File.ReadAllLines(packageSources); foreach (var source in sources) { if (string.IsNullOrEmpty(source.Trim())) { continue; } repositories.Add(PackageRepositoryFactory.Default.CreateRepository(source)); } } var aggregateRepository = new AggregateRepository(repositories); return aggregateRepository; }
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); }
private static void AssertExpectedPackageSources(AggregateRepository actualRepo, params string[] expectedSources) { foreach(string expectedSource in expectedSources) { Assert.IsTrue(actualRepo.Repositories.Any(r => string.Equals(r.Source, expectedSource)), "Expected package source does not exist: {0}", expectedSource); } Assert.AreEqual(expectedSources.Length, actualRepo.Repositories.Count(), "Too many repositories returned"); }
static void Main(string[] args) { var orchardDirectory = args[0]; var inputDirectory = args[1]; var outputDirectory = args[2]; var cacheDirectory = args[3]; var cacheFileSystem = new PhysicalFileSystem(cacheDirectory); var cachePackageResolver = new DefaultPackagePathResolver(cacheFileSystem, false); var orchardRepository = new AggregateRepository(new IPackageRepository[] { new LocalPackageRepository(orchardDirectory), new DataServicePackageRepository(new Uri("http://nuget.org/api/v2")), }); var orchardManager = new PackageManager(orchardRepository, cachePackageResolver, cacheFileSystem); var inputRepository = new LocalPackageRepository(inputDirectory); var inputManager = new PackageManager(inputRepository, cachePackageResolver, cacheFileSystem); var references = new[] { "Orchard.Core", "Orchard.Framework", "Orchard.External" }; foreach (var reference in references) orchardManager.InstallPackage(orchardRepository.FindPackage(reference), false, false); foreach (var inputPackage in inputRepository.GetPackages().Where(p => p.Id.StartsWith("Orchard.Module."))) { Do(inputRepository, inputManager, inputPackage, cacheDirectory, references, outputDirectory); } }