public void ReleasePackageIntegrationTest()
{
var inputPackage = IntegrationTestHelper.GetPath("fixtures", "Squirrel.Tests.0.1.0-pre.nupkg");
var outputPackage = Path.GetTempFileName() + ".nupkg";
var sourceDir = IntegrationTestHelper.GetPath("fixtures", "packages");
var fixture = new ReleasePackage(inputPackage);
(new DirectoryInfo(sourceDir)).Exists.ShouldBeTrue();
try {
fixture.CreateReleasePackage(outputPackage, sourceDir);
this.Log().Info("Resulting package is at {0}", outputPackage);
var pkg = new ZipPackage(outputPackage);
int refs = pkg.FrameworkAssemblies.Count();
this.Log().Info("Found {0} refs", refs);
refs.ShouldEqual(0);
this.Log().Info("Files in release package:");
List<IPackageFile> files = pkg.GetFiles().ToList();
files.ForEach(x => this.Log().Info(x.Path));
List<string> nonDesktopPaths = new[] {"sl", "winrt", "netcore", "win8", "windows8", "MonoAndroid", "MonoTouch", "MonoMac", "wp", }
.Select(x => @"lib\" + x)
.ToList();
files.Any(x => nonDesktopPaths.Any(y => x.Path.ToLowerInvariant().Contains(y.ToLowerInvariant()))).ShouldBeFalse();
files.Any(x => x.Path.ToLowerInvariant().EndsWith(@".xml")).ShouldBeFalse();
} finally {
File.Delete(outputPackage);
}
}
static void Main(string[] args)
{
Console.WriteLine("Create NuGet Package via Code");
ManifestMetadata metadata = new ManifestMetadata()
{
Authors = "Authors Name",
Version = "1.0.0.0",
Id = "NuGetId",
Description = "NuGet Package Description goes here!",
};
PackageBuilder builder = new PackageBuilder();
var path = AppDomain.CurrentDomain.BaseDirectory + "..\\..\\DemoContent\\";
builder.PopulateFiles(path, new[] { new ManifestFile { Source = "**", Target = "content" } });
builder.Populate(metadata);
using (FileStream stream = File.Open("test.nupkg", FileMode.OpenOrCreate))
{
builder.Save(stream);
}
Console.WriteLine("... and extract NuGet Package via Code");
NuGet.ZipPackage package = new ZipPackage("test.nupkg");
var content = package.GetContentFiles();
Console.WriteLine("Package Id: " + package.Id);
Console.WriteLine("Content-Files-Count: " + content.Count());
Console.ReadLine();
}
public void EigenUpdateWithoutUpdateURL()
{
string dir;
string outDir;
using (Utility.WithTempDirectory(out outDir))
using (IntegrationTestHelper.WithFakeInstallDirectory(out dir)) {
var di = new DirectoryInfo(dir);
var progress = new Subject<int>();
var bundledRelease = ReleaseEntry.GenerateFromFile(di.GetFiles("*.nupkg").First().FullName);
var fixture = new InstallManager(bundledRelease, outDir);
var pkg = new ZipPackage(Path.Combine(dir, "SampleUpdatingApp.1.1.0.0.nupkg"));
var progressValues = new List<int>();
progress.Subscribe(progressValues.Add);
fixture.ExecuteInstall(dir, pkg, progress).Wait();
var filesToLookFor = new[] {
"SampleUpdatingApp\\app-1.1.0.0\\SampleUpdatingApp.exe",
"SampleUpdatingApp\\packages\\RELEASES",
"SampleUpdatingApp\\packages\\SampleUpdatingApp.1.1.0.0.nupkg",
};
filesToLookFor.ForEach(f => Assert.True(File.Exists(Path.Combine(outDir, f)), "Could not find file: " + f));
// Progress should be monotonically increasing
progressValues.Count.ShouldBeGreaterThan(2);
progressValues.Zip(progressValues.Skip(1), (prev, cur) => cur - prev).All(x => x > 0).ShouldBeTrue();
}
}
public void NuspecMissingRequiredFieldsThrowsExceptions()
{
var path = IntegrationTestHelper.GetPath("fixtures", "Squirrel.Core.1.1.0.0.nupkg");
var zp = new ZipPackage(path);
//Use reflection to grab an instance of the private method
var checkIfNuspecHasRequiredFields = typeof(ParseCommands).GetMethod("checkIfNuspecHasRequiredFields",
BindingFlags.Static | BindingFlags.NonPublic);
zp.Id = "";
//Blank id exception
Assert.Throws<TargetInvocationException>(() => checkIfNuspecHasRequiredFields.Invoke(null, new object[] { zp, "Path" }));
zp.Id = "K";
//zp.Version = "";
//TODO: Test a blank version somehow
//zp.Version = "1.0";
zp.Authors = new string[0];
//Blank authors exception
Assert.Throws<TargetInvocationException>(() => checkIfNuspecHasRequiredFields.Invoke(null, new object[] { zp, "Path" }));
zp.Authors = new[] { "AuthorName" };
zp.Description = "";
//Blank description exception
Assert.Throws<TargetInvocationException>(() => checkIfNuspecHasRequiredFields.Invoke(null, new object[] { zp, "Path" }));
}
public void ApplyDeltaPackageSmokeTest()
{
var basePackage = new ReleasePackage(IntegrationTestHelper.GetPath("fixtures", "Shimmer.Core.1.0.0.0-full.nupkg"));
var deltaPackage = new ReleasePackage(IntegrationTestHelper.GetPath("fixtures", "Shimmer.Core.1.1.0.0-delta.nupkg"));
var expectedPackageFile = IntegrationTestHelper.GetPath("fixtures", "Shimmer.Core.1.1.0.0-full.nupkg");
var outFile = Path.GetTempFileName() + ".nupkg";
try {
basePackage.ApplyDeltaPackage(deltaPackage, outFile);
var result = new ZipPackage(outFile);
var expected = new ZipPackage(expectedPackageFile);
result.Id.ShouldEqual(expected.Id);
result.Version.ShouldEqual(expected.Version);
this.Log().Info("Expected file list:");
expected.GetFiles().Select(x => x.Path).OrderBy(x => x).ForEach(x => this.Log().Info(x));
this.Log().Info("Actual file list:");
result.GetFiles().Select(x => x.Path).OrderBy(x => x).ForEach(x => this.Log().Info(x));
Enumerable.Zip(
expected.GetFiles().Select(x => x.Path).OrderBy(x => x),
result.GetFiles().Select(x => x.Path).OrderBy(x => x),
(e, a) => e == a
).All(x => x).ShouldBeTrue();
} finally {
if (File.Exists(outFile)) {
File.Delete(outFile);
}
}
}
public static bool IsNuGetPublished (this ICakeContext context, FilePath file, string nugetSource = DefaultNuGetSource)
{
var f = file.MakeAbsolute (context.Environment).FullPath;
var pkg = new ZipPackage (f);
return IsNuGetPublished (context, pkg.Id, pkg.Version, nugetSource);
}
public static SemanticVersion GetNuGetPackageVersion (this ICakeContext context, FilePath file)
{
var f = file.MakeAbsolute (context.Environment).FullPath;
var p = new ZipPackage (f);
return p.Version;
}
public static string GetNuGetPackageId (this ICakeContext context, FilePath file)
{
var f = file.MakeAbsolute (context.Environment).FullPath;
var p = new ZipPackage (f);
return p.Id;
}
public void PublishPackage(string file, string apiKey)
{
var packageServer = new PackageServer(Feed.NuGetV2.Url, "ripple");
var package = new ZipPackage(file);
RippleLog.Info("Publishing " + file);
packageServer.PushPackage(apiKey, package.GetStream, (int)60.Minutes().TotalMilliseconds);
}
public void DetectFrameworkVersion(string packageName, FrameworkVersion expected)
{
var path = IntegrationTestHelper.GetPath("fixtures", packageName);
var zip = new ZipPackage(path);
Assert.Equal(expected, zip.DetectFrameworkVersion());
}
public void Push(string url, string key, Stream stream)
{
var package = new ZipPackage(stream);
stream = package.GetStream();
var server = new PackageServer(url, "SymbolSource");
server.PushPackage(key, package, stream.Length, 5000, false);
}
public bool TryBuild(byte[] bytes, out Package package)
{
package = null;
try
{
using (var stream = new MemoryStream(bytes))
{
var zipPackage = new ZipPackage(stream);
if (zipPackage.Id.IsTooLargeString() || zipPackage.Version.ToString().IsTooLargeString())
{
return false;
}
var now = dateTimeService.UtcNow;
package = new Package
{
Id = zipPackage.Id,
Version = zipPackage.Version.ToString(),
DisplayTitle = zipPackage.Title.ToStringSafe(),
IsAbsoluteLatestVersion = zipPackage.IsAbsoluteLatestVersion,
IsLatestVersion = zipPackage.IsLatestVersion,
IsPrerelease = zipPackage.IsPrerelease(),
PackageHash = cryptoService.Hash(bytes),
PackageHashAlgorithm = cryptoService.HashAlgorithmId,
PackageSize = bytes.LongLength,
Created = now,
LastUpdated = now,
Published = now,
Owners = zipPackage.Owners.Flatten().ToStringSafe(),
Authors = zipPackage.Authors.Flatten().ToStringSafe(),
Listed = true,
RequireLicenseAcceptance = zipPackage.RequireLicenseAcceptance,
Language = zipPackage.Language.ToStringSafe(),
DevelopmentDependency = zipPackage.DevelopmentDependency,
Title = zipPackage.Title.ToStringSafe(),
Tags = zipPackage.Tags.ToStringSafe(),
Copyright = zipPackage.Copyright.ToStringSafe(),
Dependencies = "".ToStringSafe(),
IconUrl = zipPackage.IconUrl.ToStringSafe(),
LicenseUrl = zipPackage.LicenseUrl.ToStringSafe(),
ProjectUrl = zipPackage.ProjectUrl.ToStringSafe(),
Description = zipPackage.Description.ToStringSafe(),
ReleaseNotes = zipPackage.ReleaseNotes.ToStringSafe(),
Summary = zipPackage.Summary.ToStringSafe(),
DownloadCount = 0,
Score = 0f,
VersionDownloadCount = 0,
BlobId = guidGenerator.NewGuid()
};
return true;
}
}
catch (Exception)
{
return false;
}
}
public string GetReleaseNotes(string packageDirectory)
{
var zp = new ZipPackage(Path.Combine(packageDirectory, Filename));
var t = zp.Id;
if (String.IsNullOrWhiteSpace(zp.ReleaseNotes)) {
throw new Exception(String.Format("Invalid 'ReleaseNotes' value in nuspec file at '{0}'", Path.Combine(packageDirectory, Filename)));
}
return zp.ReleaseNotes;
}
public override void ExecuteCommand()
{
Log.Info("Getting all package metadata...");
var packages = GetAllPackages();
Log.Info("Getting packages which have target framework data...");
var alreadyPopulatedPackageKeys = GetAlreadyPopulatedPackageKeys();
Log.Info("Calculating minimal difference set...");
var packageKeysToPopulate = packages.Keys.Except(alreadyPopulatedPackageKeys).ToList();
var totalCount = packageKeysToPopulate.Count;
var processedCount = 0;
Log.Info(
"Populating frameworks for {0} packages on '{1}',",
totalCount,
ConnectionString);
Parallel.ForEach(packageKeysToPopulate, new ParallelOptions { MaxDegreeOfParallelism = 10 }, packageIdToPopulate =>
{
var package = packages[packageIdToPopulate];
try
{
var downloadPath = DownloadPackage(package);
var nugetPackage = new ZipPackage(downloadPath);
var supportedFrameworks = GetSupportedFrameworks(nugetPackage);
if (!WhatIf)
{
PopulateFrameworks(package, supportedFrameworks);
}
File.Delete(downloadPath);
Interlocked.Increment(ref processedCount);
Log.Info(
"Populated frameworks for package '{0}.{1}' ({2} of {3}).",
package.Id,
package.Version,
processedCount,
totalCount);
}
catch (Exception ex)
{
Interlocked.Increment(ref processedCount);
Log.Error(
"Error populating frameworks for package '{0}.{1}' ({2} of {3}): {4}.",
package.Id,
package.Version,
processedCount,
totalCount,
ex.Message);
}
});
}
public void AddFolder(string folderPath)
{
log.Debug("Using package versions from folder: " + folderPath);
foreach (var file in Directory.GetFiles(folderPath, "*.nupkg", SearchOption.AllDirectories))
{
log.Debug("Package file: " + file);
var package = new ZipPackage(file);
Add(package.Id, package.Version.ToString());
}
}
public async Task<Package> LoadAsync(string id, string version) {
var logger = _loggerFactory.CreateLogger<NuGetPackageLoader>();
var sourceProvider = new PackageSourceProvider(
NullSettings.Instance,
new[] {
new PackageSource(NuGetConstants.DefaultFeedUrl),
new PackageSource("https://www.myget.org/F/aspnetvnext/api/v2"),
});
var feeds = sourceProvider
.LoadPackageSources()
.Select(source =>
PackageSourceUtils.CreatePackageFeed(
source,
noCache: false,
ignoreFailedSources: false,
reports: logger.CreateReports()))
.Where(f => f != null);
logger.LogInformation($"Looking up {id} v{version} from nuget");
var packages = (await Task.WhenAll(feeds.Select(feed => feed.FindPackagesByIdAsync(id))))
.SelectMany(_ => _)
.OrderByDescending(p => p.Version);
var package = version == null
? packages.FirstOrDefault()
: packages.FirstOrDefault(p => p.Version == new SemanticVersion(version));
if (package == null) {
logger.LogError($"Unable to locate {id} v{version}");
return null;
}
logger.LogInformation($"Found version {package.Version} of {package.Id}");
var pkgStreams = await Task.WhenAll(feeds.Select(feed => {
try {
return feed.OpenNupkgStreamAsync(package);
} catch {
return null;
}
}));
var pkgStream = pkgStreams.FirstOrDefault(s => s != null);
var zipPackage = new ZipPackage(pkgStream);
if (zipPackage == null) {
logger.LogError($"Unable to open package stream for {id} v{version}");
return null;
}
return zipPackage.ToPackage(packages.Select(p => p.Version.ToString()).ToList(), logger);
}
public void AddFolder(string folderPath)
{
log.Debug("Using package versions from folder: " + folderPath);
foreach (var file in Directory.GetFiles(folderPath, "*.nupkg", SearchOption.AllDirectories))
{
log.Debug("Package file: " + file);
var package = new NuGet.ZipPackage(file);
Add(package.Id, package.Version.ToString());
}
}
private List <IPackageFile> GetFilesNoCache()
{
using (Stream stream = _streamFactory())
{
Package package = Package.Open(stream);
var packageId = ZipPackage.GetPackageIdentifier(package);
return((from part in package.GetParts()
where IsPackageFile(part, packageId)
select(IPackageFile) new ZipPackageFile(part)).ToList());
}
}
public void CreateDeltaPackageIntegrationTest()
{
var basePackage = IntegrationTestHelper.GetPath("fixtures", "NSync.Core.1.0.0.0.nupkg");
var newPackage = IntegrationTestHelper.GetPath("fixtures", "NSync.Core.1.1.0.0.nupkg");
var sourceDir = IntegrationTestHelper.GetPath("..", "packages");
(new DirectoryInfo(sourceDir)).Exists.ShouldBeTrue();
var baseFixture = new ReleasePackage(basePackage);
var fixture = new ReleasePackage(newPackage);
var tempFiles = Enumerable.Range(0, 3)
.Select(_ => Path.GetTempPath() + Guid.NewGuid().ToString() + ".nupkg")
.ToArray();
try {
baseFixture.CreateReleasePackage(tempFiles[0], sourceDir);
fixture.CreateReleasePackage(tempFiles[1], sourceDir);
(new FileInfo(baseFixture.ReleasePackageFile)).Exists.ShouldBeTrue();
(new FileInfo(fixture.ReleasePackageFile)).Exists.ShouldBeTrue();
fixture.CreateDeltaPackage(baseFixture, tempFiles[2]);
var fullPkg = new ZipPackage(tempFiles[1]);
var deltaPkg = new ZipPackage(tempFiles[2]);
fullPkg.Id.ShouldEqual(deltaPkg.Id);
fullPkg.Version.CompareTo(deltaPkg.Version).ShouldEqual(0);
// v1.1 adds a dependency on DotNetZip
deltaPkg.GetFiles()
.Any(x => x.Path.ToLowerInvariant().Contains("ionic.zip"))
.ShouldBeTrue();
// All the other files should be diffs
deltaPkg.GetFiles()
.Where(x => !x.Path.ToLowerInvariant().Contains("ionic.zip"))
.All(x => x.Path.ToLowerInvariant().EndsWith("diff"))
.ShouldBeTrue();
// Delta packages should be smaller than the original!
var fileInfos = tempFiles.Select(x => new FileInfo(x)).ToArray();
this.Log().Info("Base Size: {0}, Current Size: {1}, Delta Size: {2}",
fileInfos[0].Length, fileInfos[1].Length, fileInfos[2].Length);
(fileInfos[2].Length - fileInfos[1].Length).ShouldBeLessThan(0);
} finally {
tempFiles.ForEach(File.Delete);
}
}
public void Build_And_Packaged_XCopy_Has_Correct_Metadata()
{
System.Environment.CurrentDirectory = "samples".MapVcsRoot();
MsBuild("PowerDeploy.Sample.XCopy\\PowerDeploy.Sample.XCopy.csproj /t:clean,build /p:RunOctoPack=true /p:OctoPackPackageVersion=1.3.3.7 /p:Configuration=Release /v:m");
Assert.IsTrue(File.Exists(@"PowerDeploy.Sample.XCopy\obj\octopacked\PowerDeploy.Sample.XCopy.1.3.3.7.nupkg"));
var nupkg = new ZipPackage(@"PowerDeploy.Sample.XCopy\obj\octopacked\PowerDeploy.Sample.XCopy.1.3.3.7.nupkg");
Assert.AreEqual("1.3.3.7", nupkg.Version.ToString());
Assert.AreEqual("PowerDeploy.Sample.XCopy", nupkg.Id);
Assert.IsTrue(nupkg.GetFiles().Any(f => f.Path.Contains("powerdeploy.template.xml")));
}
private void EnsurePackageFiles()
{
if (_files != null && _expandedFileSystem.DirectoryExists(_expandedFolderPath))
{
return;
}
_files = new Dictionary <string, PhysicalPackageFile>();
_supportedFrameworks = null;
using (Stream stream = GetStream())
{
Package package = Package.Open(stream);
_expandedFolderPath = GetExpandedFolderPath();
// unzip files inside package
var files = from part in package.GetParts()
where ZipPackage.IsPackageFile(part)
select part;
// now copy all package's files to disk
foreach (PackagePart file in files)
{
string path = UriUtility.GetPath(file.Uri);
string filePath = Path.Combine(_expandedFolderPath, path);
using (Stream partStream = file.GetStream())
{
// only copy the package part to disk if there doesn't exist
// a file with the same name.
if (!_expandedFileSystem.FileExists(filePath))
{
using (Stream targetStream = _expandedFileSystem.CreateFile(filePath))
{
partStream.CopyTo(targetStream);
}
}
}
var packageFile = new PhysicalPackageFile
{
SourcePath = _expandedFileSystem.GetFullPath(filePath),
TargetPath = path
};
_files[path] = packageFile;
}
}
}
protected static void AssertPackage(string packageFilePath, Action<ZipPackage> packageAssertions)
{
var fullPath = Path.Combine(Environment.CurrentDirectory, packageFilePath);
if (!File.Exists(fullPath))
{
Assert.Fail("Could not find package file: " + fullPath);
}
Trace.WriteLine("Checking package: " + fullPath);
var package = new ZipPackage(fullPath);
packageAssertions(package);
Trace.WriteLine("Success!");
}
protected override void GetMetadata(string path, string repository, out PackageProject project, out IList<MetadataEntry> metadata, out ILookup<ContentType, string> contents)
{
var packagePath = GetFilePath(path);
Version version;
using (var stream = File.OpenRead(packagePath))
version = versionExtractor.Extract(stream);
var package = new ZipPackage(packagePath);
metadata = version.Metadata;
project = new PackageProject
{
Name = version.Project,
Repository = repository,
Version =
new PackageVersion
{
Project = version.Project,
Name = version.Name,
Metadata = version.Metadata,
Compilations =
package.AssemblyReferences
.GroupBy(reference => reference.TargetFramework)
.Select(group => new PackageCompilation
{
Mode = "Release",
Platform = group.Key != null ? group.Key.ToString() : "Default",
ImageFiles =
group.Select(reference => new PackageImageFile
{
Name = reference.Path.Replace(@"\", @"/")
}
).ToArray(),
})
.ToArray(),
}
};
using (var zip = new ZipFile(packagePath))
contents = zip.EntryFileNames.ToLookup(GetContentType);
}
private static void CreatePart(Package package, string path, Stream sourceStream)
{
if (PackageHelper.IsPackageManifest(path, ZipPackage.GetPackageIdentifier(package)))
{
return;
}
Uri uri = UriUtility.CreatePartUri(path);
// Create the part
PackagePart packagePart = package.CreatePart(uri, DefaultContentType, CompressionOption.Maximum);
using (Stream stream = packagePart.GetStream())
{
sourceStream.CopyTo(stream);
}
}
public void DeployPackage(string package)
{
var nupkg = new ZipPackage(package);
var packageType = nupkg.PeekPackageType();
_logger.Info("Deploy {1} package {0}".Fmt(packageType, package));
foreach (var deployer in _pluginsLoader.Deployers)
{
if (deployer.Metadata.PackageType == packageType)
{
deployer.Value.Deploy(nupkg, _logger);
break;
}
}
}
public void CreatePackage(HttpContextBase context)
{
var request = context.Request;
var stream = request.Files.Count > 0 ? request.Files[0].InputStream : request.InputStream;
var package = new ZipPackage(stream);
var symbolFiles = package.GetFiles("lib").Where(f => Path.GetExtension(f.Path) == ".pdb").ToList();
foreach (var symbolFile in symbolFiles)
ProcessSymbolFile(symbolFile, package);
stream.Position = 0;
if (IsSymbolPackage(package, symbolFiles))
symbolPackageService.CreatePackage(context);
else
packageService.CreatePackage(context);
}
public virtual ActionResult UploadPackage(HttpPostedFileBase packageFile)
{
// TODO: validate package id and version don't already exist
if (packageFile == null)
{
ModelState.AddModelError(string.Empty, "A package file is required.");
return View();
}
// TODO: what other security checks do we need to perform for uploaded packages?
var extension = Path.GetExtension(packageFile.FileName).ToLowerInvariant();
if (extension != Const.PackageFileExtension)
{
ModelState.AddModelError(string.Empty, "The package file must be a .nupkg file.");
return View();
}
var currentUser = userSvc.FindByUsername(User.Identity.Name);
if (currentUser == null)
{
throw new InvalidOperationException("Current user is null. This should never happen!");
}
ZipPackage uploadedPackage;
using (var uploadStream = packageFile.InputStream)
{
uploadedPackage = new ZipPackage(packageFile.InputStream);
}
Package packageVersion;
try
{
packageVersion = packageSvc.CreatePackage(uploadedPackage, currentUser);
}
catch (EntityException ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return View();
}
string packagePublishUrl = Url.Publish(packageVersion);
return Redirect(packagePublishUrl);
}
internal void EnsurePackage(IPackageCacheRepository cacheRepository)
{
IPackageMetadata packageMetadata = this;
if ((((this._package == null) || ((this._package is OptimizedZipPackage) && !((OptimizedZipPackage)this._package).IsValid)) || !string.Equals(this.OldHash, this.PackageHash, StringComparison.OrdinalIgnoreCase)) || (this._usingMachineCache && !cacheRepository.Exists(this.Id, packageMetadata.Version)))
{
IPackage package = null;
bool flag = false;
bool flag2 = false;
if (TryGetPackage(cacheRepository, packageMetadata, out package) && this.MatchPackageHash(package))
{
flag2 = true;
}
else
{
if (cacheRepository.InvokeOnPackage(packageMetadata.Id, packageMetadata.Version, stream => this.Downloader.DownloadPackage(this.DownloadUrl, this, stream)))
{
package = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version);
}
else
{
using (MemoryStream stream = new MemoryStream())
{
this.Downloader.DownloadPackage(this.DownloadUrl, this, stream);
stream.Seek(0L, SeekOrigin.Begin);
package = new ZipPackage(stream);
}
flag = true;
}
flag2 = true;
}
if (!flag2)
{
object[] args = new object[] { this.Version, this.Id };
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, NuGetResources.Error_InvalidPackage, args));
}
this._package = package;
this.Id = this._package.Id;
this.Version = this._package.Version.ToString();
this._usingMachineCache = !flag;
this.OldHash = this.PackageHash;
}
}
//public PackageInfo Install(string packageId, string version, string location, string applicationFolder)
//{
// // instantiates the appropriate package repository
// IPackageRepository packageRepository = PackageRepositoryFactory.Default.CreateRepository(location);
// // gets an IPackage instance from the repository
// var packageVersion = String.IsNullOrEmpty(version) ? null : new SemanticVersion(version);
// var package = packageRepository.FindPackage(packageId, packageVersion);
// if (package == null)
// {
// throw new ArgumentException("The specified package could not be found, id:{0} version:{1}".FormatCurrent(packageId, version.IsEmpty() ? "No version" : version));
// }
// return InstallPackage(package, packageRepository, location, applicationFolder);
//}
public PackageInfo Install(Stream packageStream, string location, string applicationPath)
{
Guard.ArgumentNotNull(() => packageStream);
IPackage package = null;
try
{
package = new ZipPackage(packageStream);
}
catch (Exception ex)
{
throw new SmartException(T("Admin.Packaging.StreamError"), ex);
}
// instantiates the appropriate package repository
var packageRepository = new NullSourceRepository();
return InstallPackage(package, packageRepository, location, applicationPath);
}
public void GetSource(RequestContext context)
{
var packageId = context.RouteData.Values["id"].ToString();
var version = context.RouteData.Values["version"].ToString();
var path = Path.Combine("src", context.RouteData.Values["path"].ToString().Replace('/', '\\'));
var package = new ZipPackage(symbolPackagePathResolver.GetSymbolPackagePath(packageId, version));
string directory = Path.GetDirectoryName(path);
var file = package.GetFiles(directory).FirstOrDefault(f => string.Equals(f.Path, path, StringComparison.InvariantCultureIgnoreCase));
var response = context.HttpContext.Response;
if (file == null)
{
response.StatusCode = 404;
return;
}
response.ContentType = "binary/octet-stream";
file.GetStream().CopyTo(response.OutputStream);
}
public void Configure_XCopy_Sample_Project_With_Mocked_Environment()
{
System.Environment.CurrentDirectory = "samples".MapVcsRoot();
MsBuild("PowerDeploy.Sample.XCopy\\PowerDeploy.Sample.XCopy.csproj /t:clean,build /p:RunOctoPack=true /p:OctoPackPackageVersion=1.3.3.7 /p:Configuration=Release /v:m");
var environmentMock = new Mock<IEnvironmentProvider>();
environmentMock.Setup(prov => prov.GetEnvironment(It.IsAny<string>())).Returns(GetUnitEnvironment);
var outputPath = FileSystem.CreateTempWorkingDir();
var target = new PackageManager(environmentMock.Object);
target.ConfigurePackageByEnvironment(@"PowerDeploy.Sample.XCopy\obj\octopacked\PowerDeploy.Sample.XCopy.1.3.3.7.nupkg", "Unit", outputPath);
// check if all template files are parsed
var nupkg = new ZipPackage(Path.Combine(outputPath, "PowerDeploy.Sample.XCopy_v1.3.3.7_UNIT.nupkg"));
Assert.IsFalse(nupkg.GetFiles().Any(f => f.Path.Contains(".template.")));
AssertPackage(Path.Combine(outputPath, "PowerDeploy.Sample.XCopy_v1.3.3.7_UNIT.nupkg"),
pkg => pkg.AssertFileContent(new Dictionary<string, string>()
{
{
"powerdeploy.xml",
@"<?xml version=""1.0"" encoding=""utf-8"" ?>
<package type=""xcopy"" environment=""UNIT"">
<destination>c:\temp</destination>
</package>".ToXmlOneLine()
},
{
"App.config",
@"<?xml version=""1.0"" encoding=""utf-8"" ?>
<configuration>
<appSettings>
<add key=""variable1"" value=""Val1"" />
<add key=""variable2"" value=""Val2"" />
<add key=""default.variable"" value=""defaultvalue"" />
<add key=""env"" value=""UNIT"" />
</appSettings>
</configuration>".ToXmlOneLine()
}
}));
}
public override void ExtractContents(IFileSystem fileSystem, string extractPath)
{
using (Stream stream = _streamFactory())
{
var package = Package.Open(stream);
var packageId = ZipPackage.GetPackageIdentifier(package);
foreach (var part in package.GetParts()
.Where(p => IsPackageFile(p, packageId)))
{
var relativePath = UriUtility.GetPath(part.Uri);
var targetPath = Path.Combine(extractPath, relativePath);
using (var partStream = part.GetStream())
{
fileSystem.AddFile(targetPath, partStream);
}
}
}
}
public void ApplyDeltaWithBothBsdiffAndNormalDiffDoesntFail()
{
var basePackage = new ReleasePackage(IntegrationTestHelper.GetPath("fixtures", "slack-1.1.8-full.nupkg"));
var deltaPackage = new ReleasePackage(IntegrationTestHelper.GetPath("fixtures", "slack-1.2.0-delta.nupkg"));
var outFile = Path.GetTempFileName() + ".nupkg";
try {
var deltaBuilder = new DeltaPackageBuilder();
deltaBuilder.ApplyDeltaPackage(basePackage, deltaPackage, outFile);
var result = new ZipPackage(outFile);
result.Id.ShouldEqual("slack");
result.Version.ShouldEqual(new SemanticVersion("1.2.0"));
} finally {
if (File.Exists(outFile)) {
File.Delete(outFile);
}
}
}
private async Task EnsureNuGetExe()
{
if (await _fileStorageService.FileExistsAsync(Constants.DownloadsFolderName, "nuget.exe"))
{
// Ensure the file exists on blob storage.
return;
}
var package = _packageService.FindPackageByIdAndVersion("NuGet.CommandLine", version: null, allowPrerelease: false);
if (package == null)
{
throw new InvalidOperationException("Unable to find NuGet.CommandLine.");
}
using (Stream packageStream = await _packageFileService.DownloadPackageFileAsync(package))
{
var zipPackage = new ZipPackage(packageStream);
await ExtractNuGetExe(zipPackage);
}
}
/// <summary>
/// Syndicates the nupkg stream for use within the system.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns></returns>
public async Task<Models.Release> SyndicateAsync(Stream stream)
{
ZipPackage package = new ZipPackage(stream);
var storageFilename = string.Format("{0}.{1}.nupkg", package.Id, package.Version);
Models.Release release = await _releaseStore.GetAsync(package.Id, package.Version.ToString());
if (release == null)
{
// assume we need to publish a new release.
release = _releaseStore.Create();
}
if (stream.CanSeek)
{
stream.Seek(0, 0);
}
var streamSHA = Utilities.CalculateChecksum(stream);
if (!streamSHA.Equals(release.SHA1))
{
release.Description = package.Description;
release.IconUrl = package.IconUrl;
release.Id = package.Id;
release.Listed = package.Listed;
release.Published = DateTimeOffset.Now;
release.ReleaseNotes = package.ReleaseNotes;
release.Summary = package.Summary;
release.Tags = package.Tags;
release.Title = package.Title;
release.Version = package.Version.ToString();
release.SHA1 = streamSHA;
// update store.
await _fileService.DeleteAsync(storageFilename);
release.RelativeUri = await _fileService.StoreAsync(storageFilename, package.GetStream());
}
return await _releaseStore.StoreAsync(release);
}
internal void EnsurePackage(IPackageRepository cacheRepository)
{
// OData caches instances of DataServicePackage while updating their property values. As a result,
// the ZipPackage that we downloaded may no longer be valid (as indicated by a newer hash).
// When using MachineCache, once we've verified that the hashes match (which happens the first time around),
// we'll simply verify the file exists between successive calls.
IPackageMetadata packageMetadata = this;
bool refreshPackage = _package == null ||
!String.Equals(OldHash, PackageHash, StringComparison.OrdinalIgnoreCase) ||
(_usingMachineCache && !cacheRepository.Exists(Id, packageMetadata.Version));
if (refreshPackage &&
TryGetPackage(cacheRepository, packageMetadata, out _package) &&
_package.GetHash(HashProvider).Equals(PackageHash, StringComparison.OrdinalIgnoreCase))
{
OldHash = PackageHash;
// Reset the flag so that we no longer need to download the package since it exists and is valid.
refreshPackage = false;
// Make a note that we the backing store for the ZipPackage is the machine cache.
_usingMachineCache = true;
}
if (refreshPackage)
{
// We either do not have a package available locally or they are invalid. Download the package from the server.
_package = Downloader.DownloadPackage(DownloadUrl, this);
// Make a note that we are using an in-memory instance of the package.
_usingMachineCache = false;
// Add the package to the cache
cacheRepository.AddPackage(_package);
OldHash = PackageHash;
// Clear any cached items for this package
ZipPackage.ClearCache(_package);
}
}
//download the specified version of the package and update project reference to it. The newly downloaded package
//will be located in /packages folder. The updated project reference can be checked in corresponding .csproj file.
public bool Execute(string packageid, string projectFile, SemanticVersion version, string packages)
{
try
{
System.Console.WriteLine("-------------------------------------");
System.Console.WriteLine("Project File " + projectFile);
System.Console.WriteLine("Package "+packageid);
System.Console.WriteLine("Version "+version);
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2");
var packagePathResolver = new DefaultPackagePathResolver(packages);
var packagesFolderFileSystem = new PhysicalFileSystem(packages);
var projectSystem = new MSBuildProjectSystem(projectFile);
var localRepository = new LocalPackageRepository(packagePathResolver, packagesFolderFileSystem);
var projectManager = new ProjectManager(repo, packagePathResolver, projectSystem, localRepository);
projectManager.RemovePackageReference(packageid,true,false);
projectManager.AddPackageReference(packageid, version, true, false);
projectSystem.Save();
string filename = packageid + "." + version;
string[] s = Directory.GetFiles(packages+ @"\"+filename);
if (s.IsEmpty()) { System.Console.WriteLine("empty"); }
else
{
var nupkgFile = new PhysicalFileSystem(s[0]);
ZipPackage z = new ZipPackage(s[0]);
z.ExtractContents(nupkgFile, packages + @"\" + filename);
}
System.Console.WriteLine("Successfully updated");
return true;
}
catch (Exception e)
{
System.Console.Write("failure");
System.Console.Write(e.StackTrace);
return false;
}
}
private void EnsurePackageFiles()
{
if (_files != null &&
_expandedFolderPath != null &&
_expandedFileSystem.DirectoryExists(_expandedFolderPath))
{
return;
}
_files = new Dictionary <string, PhysicalPackageFile>();
_supportedFrameworks = null;
var packageName = new PackageName(Id, Version);
// Only use the cache for expanded folders under %temp%, or set from unit tests
if (_expandedFileSystem == _tempFileSystem || _forceUseCache)
{
Tuple <string, DateTimeOffset> cacheValue;
DateTimeOffset lastModifiedTime = _fileSystem.GetLastModified(_packagePath);
// if the cache doesn't exist, or it exists but points to a stale package,
// then we invalidate the cache and store the new entry.
if (!_cachedExpandedFolder.TryGetValue(packageName, out cacheValue) ||
cacheValue.Item2 < lastModifiedTime)
{
cacheValue = Tuple.Create(GetExpandedFolderPath(), lastModifiedTime);
_cachedExpandedFolder[packageName] = cacheValue;
}
_expandedFolderPath = cacheValue.Item1;
}
else
{
_expandedFolderPath = GetExpandedFolderPath();
}
using (Stream stream = GetStream())
{
var package = new ZipArchive(stream);
// unzip files inside package
var files = from part in package.Entries
where ZipPackage.IsPackageFile(part)
select part;
// now copy all package's files to disk
foreach (ZipArchiveEntry file in files)
{
string path = file.FullName.Replace('/', '\\').Replace("%2B", "+");
string filePath = Path.Combine(_expandedFolderPath, path);
bool copyFile = true;
if (copyFile)
{
using (Stream partStream = file.Open())
{
try
{
using (Stream targetStream = _expandedFileSystem.CreateFile(filePath))
{
partStream.CopyTo(targetStream);
}
}
catch (Exception)
{
// if the file is read-only or has an access denied issue, we just ignore it
}
}
}
var packageFile = new PhysicalPackageFile
{
SourcePath = _expandedFileSystem.GetFullPath(filePath),
TargetPath = path
};
_files[path] = packageFile;
}
}
}
private async Task <Tuple <string, string> > ResolvePackageIdAndVersion(string packageId, string packageVersion)
{
if (string.IsNullOrEmpty(packageId))
{
return(null);
}
// For nupkgs, get the id and version from the package
if (packageId.EndsWith(".nupkg", StringComparison.OrdinalIgnoreCase))
{
if (!File.Exists(packageId))
{
WriteError(string.Format("Could not find the file {0}.", packageId));
return(null);
}
var packagePath = Path.GetFullPath(packageId);
var packageDirectory = Path.GetDirectoryName(packagePath);
var zipPackage = new NuGet.ZipPackage(packagePath);
FeedOptions.FallbackSources.Add(packageDirectory);
return(new Tuple <string, string>(
zipPackage.Id,
zipPackage.Version.ToString()));
}
// If the version is missing, try to find the latest version
if (string.IsNullOrEmpty(packageVersion))
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_commandsRepository.Root.Root);
var config = NuGetConfig.ForSolution(rootDirectory, RestoreCommand.FileSystem);
var packageFeeds = new List <IPackageFeed>();
var effectiveSources = PackageSourceUtils.GetEffectivePackageSources(
config.Sources,
FeedOptions.Sources,
FeedOptions.FallbackSources);
foreach (var source in effectiveSources)
{
var feed = PackageSourceUtils.CreatePackageFeed(
source,
FeedOptions.NoCache,
FeedOptions.IgnoreFailedSources,
Reports);
if (feed != null)
{
packageFeeds.Add(feed);
}
}
var package = await PackageSourceUtils.FindLatestPackage(packageFeeds, packageId);
if (package == null)
{
Reports.Error.WriteLine("Unable to locate the package {0}".Red(), packageId);
return(null);
}
return(new Tuple <string, string>(
packageId,
package.Version.ToString()));
}
// Otherwise, just assume that what you got is correct
return(new Tuple <string, string>(packageId, packageVersion));
}
private void EnsurePackageFiles()
{
if ((this._files == null) || ((this._expandedFolderPath == null) || !this._expandedFileSystem.DirectoryExists(this._expandedFolderPath)))
{
this._files = new Dictionary <string, PhysicalPackageFile>();
this._supportedFrameworks = null;
PackageName key = new PackageName(base.Id, base.Version);
if (!ReferenceEquals(this._expandedFileSystem, _tempFileSystem) && !this._forceUseCache)
{
this._expandedFolderPath = this.GetExpandedFolderPath();
}
else
{
Tuple <string, DateTimeOffset> tuple;
DateTimeOffset lastModified = this._fileSystem.GetLastModified(this._packagePath);
if (!_cachedExpandedFolder.TryGetValue(key, out tuple) || (tuple.Item2 < lastModified))
{
tuple = Tuple.Create <string, DateTimeOffset>(this.GetExpandedFolderPath(), lastModified);
_cachedExpandedFolder[key] = tuple;
}
this._expandedFolderPath = tuple.Item1;
}
using (Stream stream = this.GetStream())
{
using (IEnumerator <PackagePart> enumerator = (from part in Package.Open(stream).GetParts()
where ZipPackage.IsPackageFile(part)
select part).GetEnumerator())
{
string path;
string str2;
goto TR_0023;
TR_000E:
PhysicalPackageFile file1 = new PhysicalPackageFile();
file1.SourcePath = this._expandedFileSystem.GetFullPath(str2);
file1.TargetPath = path;
this._files[path] = file1;
TR_0023:
while (true)
{
if (enumerator.MoveNext())
{
PackagePart current = enumerator.Current;
path = UriUtility.GetPath(current.Uri);
str2 = Path.Combine(this._expandedFolderPath, path);
bool flag = true;
if (this._expandedFileSystem.FileExists(str2))
{
using (Stream stream2 = current.GetStream())
{
using (Stream stream3 = this._expandedFileSystem.OpenFile(str2))
{
flag = stream2.Length != stream3.Length;
}
}
}
if (flag)
{
Stream stream4 = current.GetStream();
try
{
using (Stream stream5 = this._expandedFileSystem.CreateFile(str2))
{
stream4.CopyTo(stream5);
}
}
catch (Exception)
{
}
finally
{
if (stream4 != null)
{
stream4.Dispose();
}
}
}
}
else
{
return;
}
break;
}
goto TR_000E;
}
}
}
}
internal void EnsurePackage(IPackageCacheRepository cacheRepository)
{
// OData caches instances of DataServicePackage while updating their property values. As a result,
// the ZipPackage that we downloaded may no longer be valid (as indicated by a newer hash).
// When using MachineCache, once we've verified that the hashes match (which happens the first time around),
// we'll simply verify the file exists between successive calls.
IPackageMetadata packageMetadata = this;
if (_package == null ||
(_package is OptimizedZipPackage && !((OptimizedZipPackage)_package).IsValid) ||
!String.Equals(OldHash, PackageHash, StringComparison.OrdinalIgnoreCase) ||
(_usingMachineCache && !cacheRepository.Exists(Id, packageMetadata.Version)))
{
IPackage newPackage = null;
bool inMemOnly = false;
bool isValid = false;
// If the package exists in the cache and has the correct hash then use it. Otherwise download it.
if (TryGetPackage(cacheRepository, packageMetadata, out newPackage) && MatchPackageHash(newPackage))
{
isValid = true;
}
else
{
// We either do not have a package available locally or they are invalid. Download the package from the server.
if (cacheRepository.InvokeOnPackage(packageMetadata.Id, packageMetadata.Version,
(stream) => Downloader.DownloadPackage(DownloadUrl, this, stream)))
{
newPackage = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version);
Debug.Assert(newPackage != null);
}
else
{
// this can happen when access to the %LocalAppData% directory is blocked, e.g. on Windows Azure Web Site build
using (var targetStream = new MemoryStream())
{
Downloader.DownloadPackage(DownloadUrl, this, targetStream);
targetStream.Seek(0, SeekOrigin.Begin);
newPackage = new ZipPackage(targetStream);
}
inMemOnly = true;
}
// Because of CDN caching, the hash returned in odata feed
// can be out of sync with the hash of the file itself.
// So for now, we cannot call MatchPackageHash(newPackage) to
// validate that the file downloaded has the right hash.
isValid = true;
}
// apply the changes if the package hash was valid
if (isValid)
{
_package = newPackage;
// Make a note that the backing store for the ZipPackage is the machine cache.
_usingMachineCache = !inMemOnly;
OldHash = PackageHash;
}
else
{
// ensure package must end with a valid package, since we cannot load one we must throw.
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
NuGetResources.Error_InvalidPackage, Version, Id));
}
}
}
