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