private async Task <IEnumerable <string> > GetUpdatablePackageUrlsAsync(bool includePreview) { IEnumerable <string> packageUrls = new List <string>(); DirectoryPath? tempPath = null; try { var manifestPackageUrls = _workloadManifestUpdater.GetManifestPackageUrls(includePreview); packageUrls = packageUrls.Concat(manifestPackageUrls); tempPath = new DirectoryPath(Path.Combine(TempDirectoryPath, "dotnet-manifest-extraction")); await UseTempManifestsToResolvePacksAsync(tempPath.Value, includePreview); if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs)) { var installer = _workloadInstaller.GetPackInstaller(); var packsToUpdate = GetUpdatablePacks(installer) .Select(packInfo => PackageDownloader.GetPackageUrl(new PackageId(packInfo.ResolvedPackageId), new NuGetVersion(packInfo.Version), _packageSourceLocation).GetAwaiter().GetResult()); packageUrls = packageUrls.Concat(packsToUpdate); return(packageUrls); } else { throw new NotImplementedException(); } } finally { if (tempPath != null && tempPath.HasValue && Directory.Exists(tempPath.Value.Value)) { Directory.Delete(tempPath.Value.Value, true); } } }
public PlasmaDownloader(IResourcePresenceChecker checker, SpringPaths paths) { SpringPaths = paths; this.scanner = checker; //torrentDownloader = new TorrentDownloader(this); packageDownloader = new PackageDownloader(this); }
public void PackageDownloader() { packageDownloader = new PackageDownloader(ref form1, ds, progressProg, panelDownloading, labelKB, "Vysor-222inst.exe", Constants.vysorPackageLinq); ElementsZeroider(); new Thread(() => packageDownloader.VysorPackageDownloader()).Start(); }
/// <summary> /// Download the package /// </summary> /// <param name="packageUrl"></param> /// <param name="tempDirectoryName"></param> /// <returns></returns> private PackageDownloader?DownloadPackage(PackageURL packageUrl, string tempDirectoryName, bool doCache = false) { int numAttempts = 3; int numSecondsWait = 10; PackageDownloader?packageDownloader = null; while (numAttempts-- > 0) { try { packageDownloader = new PackageDownloader(packageUrl, new ProjectManagerFactory(), tempDirectoryName, doCache); packageDownloader.DownloadPackageLocalCopy(packageUrl, false, true).Wait(); break; } catch (ArgumentException) { throw; } catch (Exception) { Thread.Sleep(numSecondsWait * 1000); } } return(packageDownloader); }
void UpdateDownloadPage_Disposed(object sender, EventArgs e) { if (_downloader != null) { _downloader.Dispose(); _downloader = null; } }
public PlasmaDownloader(IPlasmaDownloaderConfig config, SpringScanner scanner, SpringPaths springPaths) { SpringPaths = springPaths; Config = config; this.scanner = scanner; //torrentDownloader = new TorrentDownloader(this); packageDownloader = new PackageDownloader(this); }
void MainForm_Disposed(object sender, EventArgs e) { if (_downloader != null) { _downloader.Dispose(); _downloader = null; } }
private IEnumerable <PackageIdentity> CreatePackageIdentityFromNupkgPath() { PackageIdentity identity = null; IPackage package = null; try { // Example: install-package2 https://az320820.vo.msecnd.net/packages/microsoft.aspnet.mvc.4.0.20505.nupkg if (_isHttp) { PackageIdentity packageIdentity = ParsePackageIdentityFromHttpSource(Id); IPackageCacheRepository packageCache = this.Projects.FirstOrDefault().TryGetFeature <IPackageCacheRepository>(); IPackageName packageName = CoreConverters.SafeToPackageName(packageIdentity); SemanticVersion packageSemVer = CoreConverters.SafeToSemanticVersion(packageIdentity.Version); Uri downloadUri = new Uri(Id); PackageDownloader downloader = new PackageDownloader(); // Try to download the package through the cache. bool success = packageCache.InvokeOnPackage( packageIdentity.Id, packageSemVer, (targetStream) => downloader.DownloadPackage( new HttpClient(downloadUri), packageName, targetStream)); if (success) { // Try to get it from the cache again package = packageCache.FindPackage(packageIdentity.Id, packageSemVer); } } else { // Example: install-package2 c:\temp\packages\jQuery.1.10.2.nupkg string fullPath = Path.GetFullPath(Id); package = new OptimizedZipPackage(fullPath); } if (package != null) { Id = package.Id; Version = package.Version.ToString(); identity = new PackageIdentity(Id, NuGetVersion.Parse(Version)); } } catch (Exception ex) { Log(MessageLevel.Error, Resources.Cmdlet_FailToParsePackages, Id, ex.Message); } return(new List <PackageIdentity>() { identity }); }
public async Task <IPackageDownload> DownloadAsync(NuGetVersion version, CancellationToken token = default(CancellationToken)) { var result = await PackageDownloader.GetDownloadResourceResultAsync(_server.Source, new PackageIdentity(Identity.Id, version), new PackageDownloadContext(new SourceCacheContext()), _server.TempDownloadLocation, _server.Logger, token).ConfigureAwait(false); if (result.Status != DownloadResourceResultStatus.Available) { throw new Exception("Failed to download"); } return(new PackageCoreReaderProxy(result.PackageReader, this, version)); }
public void CtorSetsUserAgent() { // Arrange var httpClient = new Mock<IHttpClient>(); httpClient.SetupProperty(c => c.UserAgent); // Act var downloader = new PackageDownloader(httpClient.Object); // Assert Assert.IsTrue(httpClient.Object.UserAgent.StartsWith("NuGet Visual Studio Extension/")); }
public static InstalledPackages DownloadPackages(bool ignoreDependencies, ILogProvider logProvider, ILogger logger) { logger.Info("Getting packages."); var config = new DeploymentConfiguration(logProvider); var packageDownloaderOptions = new PackageDownloaderOptions { IgnorePackageDependencies = ignoreDependencies }; var packageDownloader = new PackageDownloader(config, logProvider, packageDownloaderOptions); var installedPackages = packageDownloader.GetPackages(); return(installedPackages); }
private void MainForm_Shown(object sender, EventArgs e) { NativeMethods.SetForegroundWindow(Handle); _downloader = new PackageDownloader(Program.Arguments.Site, Program.Arguments.SiteUserName, Program.Arguments.SitePassword, Program.Arguments.Package); _downloader.DownloadCompleted += (s, ea) => DownloadComplete(ea.DownloadFolder); _downloader.DownloadFailed += (s, ea) => ShowException(ea.Exception); _downloader.Start(); _timer.Start(); }
public void CtorSetsUserAgent() { // Arrange var httpClient = new Mock <IHttpClient>(); httpClient.SetupProperty(c => c.UserAgent); // Act var downloader = new PackageDownloader(httpClient.Object); // Assert Assert.IsTrue(httpClient.Object.UserAgent.StartsWith("NuGet Visual Studio Extension/")); }
private void btnDeploy_OnClick(object sender, EventArgs e) { Cursor = Cursors.WaitCursor; var result = PackageDownloader.DownloadAndExtract(SelectedApplication.Name, SelectedEnvironment.Name, cboVersion.Text, SelectedApplication.Url, SelectedApplication.ZipFile, txtUsername.Text, txtPassword.Text); _version = result.Version; Cursor = Cursors.Arrow; RunCommandLine(result.Executable, result.WorkingDirectory); }
public DownloadUpdatePage() { InitializeComponent(); using (var metadata = Metadata.Open(Program.Arguments.Package)) { _downloader = new PackageDownloader(metadata.NuGetSite, metadata.NuGetSiteUserName, metadata.NuGetSitePassword, Program.Arguments.Package); } _downloader.DownloadCompleted += (s, ea) => DownloadComplete(ea.DownloadFolder); _downloader.DownloadFailed += (s, ea) => ShowException(ea.Exception); Disposed += UpdateDownloadPage_Disposed; }
private DownloadResourceResult LoadPackage(PackageIdentity package, PackageDownloadContext packageDownloadContext) { var downloadResourceResult = PackageDownloader.GetDownloadResourceResultAsync( repositories, package, packageDownloadContext, SettingsUtility.GetGlobalPackagesFolder(Settings.LoadDefaultSettings(null)), logger, CancellationToken.None ).Result; return(downloadResourceResult); }
public static void GetPackageAndDependencies(string packageId, string packageVersion, string sourceServer, string targetFolder, bool overwriteExistingFiles, bool includePrerelease, bool allowUnlisted, DependencyVersionTypeToDownload depVersionToDownload) { log.Trace($"Entered GetPackageAndDependencies(packageId='{packageId}', packageVersion='{packageVersion}', sourceServer='{sourceServer}', targetFolder='{targetFolder}', overwriteExistingFiles={overwriteExistingFiles}, includePrerelease={includePrerelease}, allowUnlisted={allowUnlisted}, depVersionToDownload={depVersionToDownload})"); var repo = PackageRepositoryFactory.Default.CreateRepository(sourceServer); var package = repo.FindPackage(packageId, packageVersion == null?null:new SemanticVersion(packageVersion), NullConstraintProvider.Instance, includePrerelease, allowUnlisted) as DataServicePackage; if (package == null) { log.Warn($"Package '{packageId} {packageVersion}' could not be found in the repository '{sourceServer}', or it could be converted as DataServicePackage"); return; } var finalPackagePath = Path.Combine(targetFolder, $"{package.Id}.{package.Version}.nupkg"); if (File.Exists(finalPackagePath) && !overwriteExistingFiles) { log.Info($"Skipping '{finalPackagePath}'"); return; } if (!Directory.Exists(targetFolder)) { Directory.CreateDirectory(targetFolder); } using (var fs = File.Open(finalPackagePath, FileMode.Create)) { log.Debug($"Downloading package '{package.Id}' from '{package.DownloadUrl}' ... "); var downloader = new PackageDownloader(); downloader.DownloadPackage(package.DownloadUrl, package, fs); log.Info($"Package {package.Id} downloaded!"); } foreach (var dset in package.DependencySets.Where(dset => dset.Dependencies.Count > 0)) { log.Debug($"Processing dependency set: {dset.TargetFramework?.ToString() ?? "<default set>"} "); foreach (var dep in dset.Dependencies) { log.Debug($"Processing dependency '{dep.Id}'"); var dependencyVersion = depVersionToDownload == DependencyVersionTypeToDownload.Max ? dep.VersionSpec?.MaxVersion?.ToString() : dep.VersionSpec?.MinVersion?.ToString(); GetPackageAndDependencies(dep.Id, dependencyVersion, sourceServer, targetFolder, overwriteExistingFiles, includePrerelease, allowUnlisted, depVersionToDownload); } } log.Trace("Exiting GetPackageAndDependencies"); }
private static void DownloadPackages(ILogger logger, DeployArguments arguments) { if (!arguments.DeployDatabaseOnly) { logger.Trace("Getting packages."); var config = new DeploymentConfiguration(DeploymentUtility.InitializationLogProvider); var packageDownloaderOptions = new PackageDownloaderOptions { IgnorePackageDependencies = arguments.IgnorePackageDependencies }; var packageDownloader = new PackageDownloader(config, DeploymentUtility.InitializationLogProvider, packageDownloaderOptions); var packages = packageDownloader.GetPackages(); InstalledPackages.Save(packages); } else logger.Info("Skipped download packages (DeployDatabaseOnly)."); }
public void DownloadPackageWithUnverifiedPackageThrowsInvalidDataException() { // Arrange var downloadClient = new Mock<IHttpClient>(); downloadClient.Setup(c => c.DownloadData()).Returns(new byte[] { 123 }); var hashProvider = new Mock<IHashProvider>(); hashProvider.Setup(h => h.VerifyHash(It.IsAny<byte[]>(), It.IsAny<byte[]>())).Returns(false); var packageFactory = new Mock<IPackageFactory>(); packageFactory.Setup(f => f.CreatePackage(It.IsAny<Func<Stream>>())).Returns(new Mock<IPackage>().Object).Callback<Func<Stream>>(streamFactory => streamFactory()); var downloader = new PackageDownloader(packageFactory.Object, hashProvider.Object); var package = PackageUtility.CreatePackage("A", "1.0"); // Act, Assert ExceptionAssert.Throws<InvalidDataException>(() => downloader.DownloadPackage(downloadClient.Object, new byte[0], package)); }
private async Task ConsumeItemAsync(PackageIdentity package) { Console.WriteLine($"Processing {package}"); DownloadResourceResult result = await PackageDownloader.GetDownloadResourceResultAsync(this.Sources, package, this.DownloadCache, this.DownloadDirectory, DebugLogger.Instance, CancellationToken.None); foreach (PackageDependencyGroup dependencyGroup in await result.PackageReader.GetPackageDependenciesAsync(CancellationToken.None)) { foreach (PackageDependency dependency in dependencyGroup.Packages) { PackageIdentity dependencyPackage = new PackageIdentity(dependency.Id, dependency.VersionRange.MaxVersion ?? dependency.VersionRange.MinVersion); this.TryQueue(dependencyPackage); } } }
private async Task <bool> ProcessPackageDetailsViaHttpAsync( HttpClient client, string id, string version, Uri sourceUri, PackageDetailsCatalogLeaf catalogLeaf, Dictionary <string, string> telemetryProperties, CancellationToken cancellationToken) { var packageDownloader = new PackageDownloader(client, _logger); var requestUri = Utilities.GetNugetCacheBustingUri(sourceUri); using (var stream = await packageDownloader.DownloadAsync(requestUri, cancellationToken)) { if (stream == null) { _logger.LogWarning("Package {Id}/{Version} not found.", id, version); return(false); } telemetryProperties[TelemetryConstants.SizeInBytes] = stream.Length.ToString(); var nuspec = GetNuspec(stream, id); if (nuspec == null) { _logger.LogWarning("No .nuspec available for {Id}/{Version}. Skipping.", id, version); return(false); } stream.Position = 0; await _dnxMaker.AddPackageAsync( stream, nuspec, id, version, catalogLeaf.IconFile, cancellationToken); } _logger.LogInformation("Added .nupkg and .nuspec for package {Id}/{Version}", id, version); return(true); }
/// <summary> /// /// </summary> void LaunchDownloader() { downloader_ = gameObject.GetComponent <PackageDownloader>(); if (downloader_ == null) { downloader_ = gameObject.AddComponent <PackageDownloader>(); } List <string> url_group = new List <string>(); url_group.Add(URL); List <string> package_group = new List <string>(); package_group.Add(PACKAGE_NAME); downloader_.StartDownload(url_group, package_group); }
public static async Task Download( IMonoDevelopSolutionManager solutionManager, PackageIdentity packageIdentity, INuGetProjectContext context, CancellationToken token) { if (!IsMissing(solutionManager, packageIdentity)) { return; } await PackageDownloader.GetDownloadResourceResultAsync( solutionManager.CreateSourceRepositoryProvider().GetRepositories(), packageIdentity, solutionManager.Settings, new LoggerAdapter (context), token); }
private async Task <PrimarySignature> GetPrimarySignatureOrNullAsync(ValidationContext context) { var downloader = new PackageDownloader(context.Client, Logger); var uri = GetV3PackageUri(context); using (var packageStream = await downloader.DownloadAsync(uri, context.CancellationToken)) { if (packageStream == null) { throw new InvalidOperationException($"Package {context.Package.Id} {context.Package.Version} couldn't be downloaded at {uri}"); } using (var package = new PackageArchiveReader(packageStream)) { return(await package.GetPrimarySignatureAsync(context.CancellationToken)); } } }
public CacheServiceIntegrationTest(ITestOutputHelper helper) { var logger = new XunitLoggerProvider(helper); tempDir = new TempDir(); IPackageCacheService localPackages = new FileSystemPackageCacheService(tempDir.UniqueTempFolder); IPackageDownloader downloader = new PackageDownloader(new System.Net.Http.HttpClient(), logger.CreateLogger <PackageDownloader>("CacheServiceItest")); CacheOptions options = new CacheOptions() { Enabled = true, UpstreamIndex = new System.Uri("https://api.nuget.org/v3/index.json"), PackagesPath = tempDir.UniqueTempFolder, PackageDownloadTimeoutSeconds = 10 }; mirrorService = new CacheService(new NuGetClient(logger.CreateLogger <NuGetClient>("CacheServiceItest")), localPackages, downloader, logger.CreateLogger <CacheService>("CacheServiceItest"), options); }
internal async Task SelfUpdate(string exePath, NuGetVersion version) { Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandCheckingForUpdates"), NuGetConstants.DefaultFeedUrl); var metadataResource = _source.GetResource <MetadataResource>(); if (metadataResource != null) { ResolutionContext resolutionContext = new ResolutionContext(); var latestVersionKeyPair = await metadataResource.GetLatestVersions(new List <string>() { NuGetCommandLinePackageId }, resolutionContext.IncludePrerelease, resolutionContext.IncludeUnlisted, CancellationToken.None); var lastetVersion = latestVersionKeyPair.FirstOrDefault().Value; if (version >= lastetVersion) { Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandNuGetUpToDate")); } else { Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandUpdatingNuGet"), lastetVersion.Version.ToString()); // Get NuGet.exe file using (var targetPackageStream = new MemoryStream()) { await PackageDownloader.GetPackageStream(_source, new PackageIdentity(NuGetCommandLinePackageId, lastetVersion), targetPackageStream, CancellationToken.None); // If for some reason this package doesn't have NuGet.exe then we don't want to use it if (targetPackageStream == 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, targetPackageStream); Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandUpdateSuccessful")); } } } }
static void Main(string[] args) { var loc = new ServiceLocator(); loc.NuGetFeedUri = "https://www.myget.org/F/fcepacks/api/v3/index.json"; var search = new PackageSearcher(loc); var downloader = new PackageDownloader(loc); var nugetpreproc = new NugetPreProcessor(new NuGetProcessorSettings(), downloader, search); var runner = new ScriptRunner(new IScriptPreCompileHandler[] { new ScriptBootStrap(), new ExtensionMethodHandler(), nugetpreproc }); try { var script = new StringBuilder(); //script.AppendLine("#n nuget:?package=FlexibleConfigEngine&version=0.1.0-unstable.2&prerelease"); script.AppendLine("#n nuget:?file=D:\\Sandpit\\testbucketofdoom\\semver\\2.0.4\\semver.2.0.4.nupkg"); script.AppendLine("using Semver;"); script.AppendLine("Echo(Sum(1, 2).ToString());"); script.AppendLine("var v = SemVersion.Parse(\"1.1.0-rc.1+nightly.2345\");"); script.AppendLine("Echo(v.ToString());"); script.AppendLine("Echo(\"Hey {0} {1}\", \"1\", 2);"); //var builder = new ScriptBuilder(); //builder.AppendScriptFile("test.csx"); //runner.ExecuteString(builder.ToString()).Wait(); runner.ExecuteString(script.ToString()).Wait(); Console.WriteLine(runner.Script); //foreach(var asm in AppDomain.CurrentDomain.GetAssemblies()) // Console.WriteLine($"{asm.CodeBase} - {asm.FullName}"); } catch (Exception e) { Console.WriteLine("Exception: " + e.ToString()); Console.WriteLine(runner.Script); } Console.Read(); }
private async Task <IEnumerable <string> > GetPackageDownloadUrlsAsync(IEnumerable <WorkloadId> workloadIds, bool skipManifestUpdate, bool includePreview) { var packageUrls = new List <string>(); DirectoryPath?tempPath = null; try { if (!skipManifestUpdate) { var manifestPackageUrls = _workloadManifestUpdater.GetManifestPackageUrls(includePreview); packageUrls.AddRange(manifestPackageUrls); tempPath = new DirectoryPath(Path.Combine(TempDirectoryPath, "dotnet-manifest-extraction")); await UseTempManifestsToResolvePacksAsync(tempPath.Value, includePreview); var installedWorkloads = _workloadInstaller.GetWorkloadInstallationRecordRepository().GetInstalledWorkloads(new SdkFeatureBand(_sdkVersion)); workloadIds = workloadIds.Concat(installedWorkloads).Distinct(); } if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs)) { var installer = _workloadInstaller.GetPackInstaller(); var packUrls = GetPacksToInstall(workloadIds) .Select(pack => PackageDownloader.GetPackageUrl(new PackageId(pack.ResolvedPackageId), new NuGetVersion(pack.Version), packageSourceLocation: _packageSourceLocation, includePreview: includePreview).GetAwaiter().GetResult()); packageUrls.AddRange(packUrls); } else { throw new NotImplementedException(); } return(packageUrls); } finally { if (tempPath != null && tempPath.HasValue && Directory.Exists(tempPath.Value.Value)) { Directory.Delete(tempPath.Value.Value, true); } } }
static void RunPackageDownloader(BlockingCollection <DataServicePackage> packages, string localDirectory) { while (!packages.IsCompleted) { DataServicePackage p; try { p = packages.Take(); } catch (InvalidOperationException) { Console.WriteLine("Adding was completed!"); return; } var sb = new StringBuilder(); var pkgFilename = sb.Append(p.Id).Append(".").Append(p.Version).Append(@".nupkg"); var packageFile = Path.Combine(localDirectory, pkgFilename.ToString()); if (!File.Exists(packageFile)) { Console.WriteLine("Package {0} does not exists. Downloading...", p); using (var fs = new FileStream(packageFile, FileMode.Create)) { try { var pd = new PackageDownloader(); pd.DownloadPackage(p.DownloadUrl, p, fs); } catch (Exception e) { Console.WriteLine(e); } } } else { Console.WriteLine("Package {0} exists", p); } } Console.WriteLine("\r\nNo more items to take. Press the Enter key to exit."); }
public TriggerDeploymentResponse Post(TriggerDeployment request) { using (var session = DocumentStore.OpenSession()) { var environment = session.Query <Environment>().FirstOrDefault(e => e.Name == request.Environment); if (environment == null) { throw HttpError.NotFound("Environment {0} not found.".Fmt(request.Environment)); } var deploymentInfo = new Deployment() { EnvironmentId = "environments/" + environment.Id, RequestedAt = DateTime.UtcNow, }; var packageInfo = session.Load <Package>("packages/{0}/{1}".Fmt(request.PackageId, request.Version)); deploymentInfo.Package = packageInfo; deploymentInfo.Status = DeployStatus.Deploying; session.Store(deploymentInfo); session.SaveChanges(); using (var workspace = new Workspace(FileSystem, ServerSettings)) { var neutralPackagePath = PackageDownloader.Downloaad(request.PackageId, request.Version, workspace.TempWorkDir); workspace.UpdateSources(); var packageManager = new PackageManager(workspace.EnviornmentPath); var configuredPackage = packageManager.ConfigurePackageByEnvironment(neutralPackagePath, request.Environment, workspace.TempWorkDir); packageManager.DeployPackage(configuredPackage); deploymentInfo.FinishedAt = DateTime.UtcNow; deploymentInfo.Status = DeployStatus.Successful; session.SaveChanges(); return(new TriggerDeploymentResponse()); } } }
private async Task <bool> ProcessPackageDetailsViaHttpAsync( HttpClient client, string id, string version, Uri sourceUri, CancellationToken cancellationToken) { var packageDownloader = new PackageDownloader(client, _logger); var requestUri = Utilities.GetNugetCacheBustingUri(sourceUri); using (var stream = await packageDownloader.DownloadAsync(requestUri, cancellationToken)) { if (stream == null) { _logger.LogWarning("Package {Id}/{Version} not found.", id, version); return(false); } var nuspec = GetNuspec(stream, id); if (nuspec == null) { _logger.LogWarning("No .nuspec available for {Id}/{Version}. Skipping.", id, version); return(false); } stream.Position = 0; await _dnxMaker.AddPackageAsync( stream, nuspec, id, version, cancellationToken); } _logger.LogInformation("Added .nupkg and .nuspec for package {Id}/{Version}", id, version); return(true); }
public static async Task DownloadAsync(string packageId, string version) { var package = new PackageIdentity(packageId, NuGetVersion.Parse(version)); var settings = Settings.LoadDefaultSettings(null); var globalFolder = SettingsUtility.GetGlobalPackagesFolder(settings); var logger = NullLogger.Instance; var cancelToken = CancellationToken.None; var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3()); var downloadFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Download"); using (var cacheContext = new SourceCacheContext()) { var downloadContext = new PackageDownloadContext(cacheContext, downloadFolder, true); var repositories = sourceRepositoryProvider.GetRepositories(); foreach (var repository in repositories) { var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(repository, package, downloadContext, globalFolder, logger, cancelToken); if (downloadResult != null) { var downloadFile = $@"{downloadFolder}\{package.Id}.{package.Version}.nupkg"; using (var fileStream = File.Create(downloadFile)) { downloadResult.PackageStream.Seek(0, SeekOrigin.Begin); await downloadResult.PackageStream.CopyToAsync(fileStream); } break; } } } }
public void DownloadPackageWithUnverifiedPackageThrowsInvalidDataException() { // Arrange var response = new Mock<WebResponse>(); response.Setup(r => r.GetResponseStream()).Returns(new MemoryStream(new byte[] { 123 })); var request = new Mock<WebRequest>(); request.Setup(r => r.GetResponse()).Returns(response.Object); var httpClient = new Mock<IHttpClient>(); httpClient.Setup(c => c.CreateRequest(It.IsAny<Uri>(), It.IsAny<bool>())).Returns(request.Object); var hashProvider = new Mock<IHashProvider>(); hashProvider.Setup(h => h.VerifyHash(It.IsAny<byte[]>(), It.IsAny<byte[]>())).Returns(false); var packageFactory = new Mock<IPackageFactory>(); packageFactory.Setup(f => f.CreatePackage(It.IsAny<Func<Stream>>())).Returns(new Mock<IPackage>().Object).Callback<Func<Stream>>(streamFactory => streamFactory()); var downloader = new PackageDownloader(httpClient.Object, packageFactory.Object, hashProvider.Object); var package = PackageUtility.CreatePackage("A", "1.0"); // Act, Assert ExceptionAssert.Throws<InvalidDataException>(() => downloader.DownloadPackage(new Uri("http://example.com/"), new byte[0], package)); }
private IEnumerable<PackageIdentity> CreatePackageIdentityFromNupkgPath() { PackageIdentity identity = null; IPackage package = null; try { // Example: install-package2 https://az320820.vo.msecnd.net/packages/microsoft.aspnet.mvc.4.0.20505.nupkg if (_isHttp) { PackageIdentity packageIdentity = ParsePackageIdentityFromHttpSource(Id); IPackageCacheRepository packageCache = this.Projects.FirstOrDefault().TryGetFeature<IPackageCacheRepository>(); IPackageName packageName = CoreConverters.SafeToPackageName(packageIdentity); SemanticVersion packageSemVer = CoreConverters.SafeToSemanticVersion(packageIdentity.Version); Uri downloadUri = new Uri(Id); PackageDownloader downloader = new PackageDownloader(); // Try to download the package through the cache. bool success = packageCache.InvokeOnPackage( packageIdentity.Id, packageSemVer, (targetStream) => downloader.DownloadPackage( new HttpClient(downloadUri), packageName, targetStream)); if (success) { // Try to get it from the cache again package = packageCache.FindPackage(packageIdentity.Id, packageSemVer); } } else { // Example: install-package2 c:\temp\packages\jQuery.1.10.2.nupkg string fullPath = Path.GetFullPath(Id); package = new OptimizedZipPackage(fullPath); } if (package != null) { Id = package.Id; Version = package.Version.ToString(); identity = new PackageIdentity(Id, NuGetVersion.Parse(Version)); } } catch (Exception ex) { Log(MessageLevel.Error, Resources.Cmdlet_FailToParsePackages, Id, ex.Message); } return new List<PackageIdentity>() { identity }; }
private static void DownloadPackages(ILogger logger, Arguments arguments) { var obsoleteFolders = new string[] { Path.Combine(Paths.RhetosServerRootPath, "DslScripts"), Path.Combine(Paths.RhetosServerRootPath, "DataMigration") }; var obsoleteFolder = obsoleteFolders.FirstOrDefault(folder => Directory.Exists(folder)); if (obsoleteFolder != null) throw new UserException("Backup all Rhetos server folders and delete obsolete folder '" + obsoleteFolder + "'. It is no longer used."); if (!arguments.DeployDatabaseOnly) { logger.Trace("Getting packages."); var config = new DeploymentConfiguration(DeploymentUtility.InitializationLogProvider); var packageDownloaderOptions = new PackageDownloaderOptions { IgnorePackageDependencies = arguments.IgnorePackageDependencies }; var packageDownloader = new PackageDownloader(config, DeploymentUtility.InitializationLogProvider, packageDownloaderOptions); var packages = packageDownloader.GetPackages(); InstalledPackages.Save(packages); } else logger.Info("Skipped download packages (DeployDatabaseOnly)."); }
internal static IPackage GetPackage(IPackageCacheRepository packageCache, PackageIdentity packageIdentity, Uri downloadUri) { var packageSemVer = CoreConverters.SafeToSemanticVersion(packageIdentity.Version); var packageName = CoreConverters.SafeToPackageName(packageIdentity); var downloader = new PackageDownloader(); IPackage package = null; if (packageCache != null) { package = packageCache.FindPackage(packageName.Id, packageSemVer); if (package != null) { NuGetTraceSources.ActionExecutor.Info( "download/cachehit", "[{0}] Download: Cache Hit!", packageIdentity); // Success! return package; } if (downloadUri == null) { throw new InvalidOperationException(String.Format( CultureInfo.CurrentCulture, Strings.DownloadActionHandler_NoDownloadUrl, packageIdentity)); } // Try to download the package through the cache. bool success = packageCache.InvokeOnPackage( packageIdentity.Id, packageSemVer, (targetStream) => downloader.DownloadPackage( new HttpClient(downloadUri), packageName, targetStream)); if (success) { NuGetTraceSources.ActionExecutor.Info( "download/downloadedtocache", "[{0}] Download: Downloaded to cache", packageName); // Try to get it from the cache again package = packageCache.FindPackage(packageIdentity.Id, packageSemVer); } } // Either: // 1. We failed to load the package into the cache, which can happen when // access to the %LocalAppData% directory is blocked, // e.g. on Windows Azure Web Site build OR // B. It was purged from the cache before it could be retrieved again. // Regardless, the cache isn't working for us, so download it in to memory. if (package == null) { NuGetTraceSources.ActionExecutor.Info( "download/cachefailing", "[{0}] Download: Cache isn't working. Downloading to RAM", packageName); using (var targetStream = new MemoryStream()) { downloader.DownloadPackage( new HttpClient(downloadUri), packageName, targetStream); targetStream.Seek(0, SeekOrigin.Begin); package = new ZipPackage(targetStream); } } return package; }