public void PackageBuilderWorksWithFileNamesContainingSpecialCharacters() { // Arrange var fileNames = new[] { @"lib\regular.file.dll", @"lib\name with spaces.dll", @"lib\C#\test.dll", @"content\images\logo123?#78.png", @"content\images\bread&butter.jpg", }; // Act var builder = new PackageBuilder { Id = "test", Version = new Version("1.0"), Description = "test" }; builder.Authors.Add("test"); foreach (var name in fileNames) { builder.Files.Add(CreatePackageFile(name)); } // Assert using (MemoryStream stream = new MemoryStream()) { builder.Save(stream); var zipPackage = new ZipPackage(() => new MemoryStream(stream.ToArray())); Assert.AreEqual(@"content\images\bread&butter.jpg", zipPackage.GetFiles().ElementAt(0).Path); Assert.AreEqual(@"content\images\logo123?#78.png", zipPackage.GetFiles().ElementAt(1).Path); Assert.AreEqual(@"lib\C#\test.dll", zipPackage.GetFiles().ElementAt(2).Path); Assert.AreEqual(@"lib\name with spaces.dll", zipPackage.GetFiles().ElementAt(3).Path); Assert.AreEqual(@"lib\regular.file.dll", zipPackage.GetFiles().ElementAt(4).Path); } }
public void ApplyDeltaPackageSmokeTest() { var basePackage = new ReleasePackage(IntegrationTestHelper.GetPath("fixtures", "Squirrel.Core.1.0.0.0-full.nupkg")); var deltaPackage = new ReleasePackage(IntegrationTestHelper.GetPath("fixtures", "Squirrel.Core.1.1.0.0-delta.nupkg")); var expectedPackageFile = IntegrationTestHelper.GetPath("fixtures", "Squirrel.Core.1.1.0.0-full.nupkg"); var outFile = Path.GetTempFileName() + ".nupkg"; try { var deltaBuilder = new DeltaPackageBuilder(); deltaBuilder.ApplyDeltaPackage(basePackage, 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 void ReleasePackageIntegrationTest() { var inputPackage = IntegrationTestHelper.GetPath("fixtures", "Shimmer.Core.1.0.0.0.nupkg"); var outputPackage = Path.GetTempFileName() + ".nupkg"; var sourceDir = IntegrationTestHelper.GetPath("..", "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:"); pkg.GetFiles().ForEach(x => this.Log().Info(x.Path)); pkg.GetFiles().Any(x => x.Path.ToLowerInvariant().Contains(@"lib\sl")).ShouldBeFalse(); pkg.GetFiles().Any(x => x.Path.ToLowerInvariant().Contains(@".xml")).ShouldBeFalse(); } finally { File.Delete(outputPackage); } }
public void CtorWithStream() { // Arrange var builder = new PackageBuilder(); builder.Id = "Package"; builder.Version = new Version("1.0"); builder.Authors.Add("David"); builder.Description = "This is a test package"; builder.Files.AddRange(PackageUtility.CreateFiles(new[] { @"lib\40\A.dll", @"content\foo" })); var ms = new MemoryStream(); builder.Save(ms); ms.Seek(0, SeekOrigin.Begin); // Act var package = new ZipPackage(ms); // Assert Assert.AreEqual("Package", package.Id); Assert.AreEqual(new Version("1.0"), package.Version); Assert.AreEqual("David", package.Authors.First()); var files = package.GetFiles().ToList(); Assert.AreEqual(2, files.Count); Assert.AreEqual(@"content\foo", files[0].Path); Assert.AreEqual(@"lib\40\A.dll", files[1].Path); var assemblyReferences = package.AssemblyReferences.ToList(); Assert.AreEqual(1, assemblyReferences.Count); Assert.AreEqual("A.dll", assemblyReferences[0].Name); Assert.AreEqual(new FrameworkName(".NETFramework", new Version("4.0")), assemblyReferences[0].TargetFramework); }
public void ReleasePackageIntegrationTest() { var inputPackage = IntegrationTestHelper.GetPath("fixtures", "Squirrel.Core.1.0.0.0.nupkg"); var outputPackage = Path.GetTempFileName() + ".nupkg"; var sourceDir = IntegrationTestHelper.GetPath("..", "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().Contains(@".xml")).ShouldBeFalse(); } finally { File.Delete(outputPackage); } }
public void CtorWithStream() { // Arrange var builder = new PackageBuilder(); builder.Id = "Package"; builder.Version = new SemanticVersion("1.0"); builder.Authors.Add("David"); builder.Description = "This is a test package"; builder.ReleaseNotes = "This is a release note."; builder.Copyright = "Copyright"; builder.Files.AddRange(PackageUtility.CreateFiles(new[] { @"lib\40\A.dll", @"content\foo" })); var ms = new MemoryStream(); builder.Save(ms); ms.Seek(0, SeekOrigin.Begin); // Act var package = new ZipPackage(ms); // Assert Assert.Equal("Package", package.Id); Assert.Equal(new SemanticVersion("1.0"), package.Version); Assert.Equal("David", package.Authors.First()); Assert.Equal("Copyright", package.Copyright); var files = package.GetFiles().ToList(); Assert.Equal(2, files.Count); Assert.Equal(@"content\foo", files[0].Path); Assert.Equal(@"lib\40\A.dll", files[1].Path); var assemblyReferences = package.AssemblyReferences.ToList(); Assert.Equal(1, assemblyReferences.Count); Assert.Equal("A.dll", assemblyReferences[0].Name); Assert.Equal(new FrameworkName(".NETFramework", new Version("4.0")), assemblyReferences[0].TargetFramework); Assert.Equal("This is a release note.", package.ReleaseNotes); }
public IPackage ExplodeTo(string directory) { var explodedDirectory = ExplodedDirectory(directory); RippleLog.Info("Exploding to " + explodedDirectory); var fileSystem = new FileSystem(); fileSystem.CreateDirectory(explodedDirectory); fileSystem.ForceClean(explodedDirectory); var package = new ZipPackage(_path); package.GetFiles().Each(file => { var target = explodedDirectory.AppendPath(file.Path); fileSystem.CreateDirectory(target.ParentDirectory()); using (var stream = new FileStream(target, FileMode.Create, FileAccess.Write)) { file.GetStream().CopyTo(stream); } }); fileSystem.CopyToDirectory(_path, explodedDirectory); fileSystem.DeleteFile(_path); var newFile = Path.Combine(explodedDirectory, Path.GetFileName(_path)); return(new ZipPackage(newFile)); }
public override SolutionPackageBase Unpack(Stream package, SolutionPackageOptions options) { package.Position = 0; var zipPackage = new ZipPackage(package); var solutionPackageFile = FindSolutionPackageFile(zipPackage); SerializationService.RegisterKnownType(typeof(SolutionPackageBase)); //SerializationService.RegisterKnownType(typeof(SPMeta2SolutionPackage)); using (var streamReader = new StreamReader(solutionPackageFile.GetStream())) { var solutionFileContent = streamReader.ReadToEnd(); var solutionPackage = SerializationService.Deserialize(typeof(SolutionPackageBase), solutionFileContent) as SolutionPackageBase; var modelContainerFiles = zipPackage.GetFiles(MetaPackConsts.ModelsContainerFolder); foreach (var modelContainerFile in modelContainerFiles) { using (var modelContainerStream = modelContainerFile.GetStream()) { var modelContainerBinary = modelContainerStream.ReadToEnd(); var modelContainer = SerializationService.Deserialize(typeof(ModelContainerBase), modelContainerBinary) as ModelContainerBase; solutionPackage.AddModel(modelContainer); } } return(solutionPackage); } }
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 response = context.HttpContext.Response; ZipPackage package; try { package = new ZipPackage(symbolPackagePathResolver.GetSymbolSourcePath(packageId, version)); } catch (FileNotFoundException) { response.StatusCode = 404; return; } string directory = Path.GetDirectoryName(path); var file = package.GetFiles(directory) .FirstOrDefault(f => string.Equals(f.Path, path, StringComparison.InvariantCultureIgnoreCase)); if (file == null) { response.StatusCode = 404; return; } response.ContentType = "binary/octet-stream"; file.GetStream().CopyTo(response.OutputStream); }
private ZipPackage VerifyPackageContents(string packageFile, IEnumerable <string> expectedFiles) { var package = new ZipPackage(packageFile); var files = package.GetFiles().Select(f => f.Path).OrderBy(f => f).ToList(); CollectionAssert.AreEqual(expectedFiles.OrderBy(f => f).ToList(), files); return(package); }
public static T GetPackageOptions <T>(this ZipPackage package) where T : class { var descriptor = package.GetFiles().FirstOrDefault(f => f.Path == "powerdeploy.xml"); if (descriptor == null) { throw new InvalidOperationException("The package {0} has no powerdeploy.xml. Please create a valid package first!".Fmt(package.Id)); } return(descriptor.GetStream().FromXml <T>()); }
public void CanResolveMultipleLevelsOfDependencies() { var inputPackage = IntegrationTestHelper.GetPath("fixtures", "SampleUpdatingApp.1.0.0.0.nupkg"); var outputPackage = Path.GetTempFileName() + ".nupkg"; var sourceDir = IntegrationTestHelper.GetPath("..", "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:"); pkg.GetFiles().ForEach(x => this.Log().Info(x.Path)); var filesToLookFor = new[] { "System.Reactive.Core.dll", "ReactiveUI.dll", "MarkdownSharp.dll", "SampleUpdatingApp.exe", }; filesToLookFor.ForEach(name => { this.Log().Info("Looking for {0}", name); pkg.GetFiles().Any(y => y.Path.ToLowerInvariant().Contains(name.ToLowerInvariant())).ShouldBeTrue(); }); } finally { File.Delete(outputPackage); } }
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"))); }
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 void CtorWithStream() { // Arrange var builder = new PackageBuilder(); builder.Id = "Package"; builder.Version = new SemanticVersion("1.0"); builder.Authors.Add("David"); builder.Description = "This is a test package"; builder.ReleaseNotes = "This is a release note."; builder.Copyright = "Copyright"; builder.Files.AddRange(PackageUtility.CreateFiles(new[] { PathFixUtility.FixPath(@"lib\40\A.dll"), PathFixUtility.FixPath(@"content\foo") })); var ms = new MemoryStream(); builder.Save(ms); ms.Seek(0, SeekOrigin.Begin); // Act var package = new ZipPackage(ms); // Assert Assert.Equal("Package", package.Id); Assert.Equal(new SemanticVersion("1.0"), package.Version); Assert.Equal("David", package.Authors.First()); Assert.Equal("Copyright", package.Copyright); //Order is not gauranteed (or required) from GetFiles(), //but we rely on the order for a few of the asserts, //and it appears to not behave the same way on Mono, //so we call "order by" here to force a specific order. var files = package.GetFiles().OrderBy(k => k.Path).ToList(); Assert.Equal(2, files.Count); Assert.Equal(PathFixUtility.FixPath(@"content\foo"), files[0].Path); Assert.Equal(PathFixUtility.FixPath(@"lib\40\A.dll"), files[1].Path); var assemblyReferences = package.AssemblyReferences.ToList(); Assert.Equal(1, assemblyReferences.Count); Assert.Equal("A.dll", assemblyReferences[0].Name); Assert.Equal(new FrameworkName(".NETFramework", new Version("4.0")), assemblyReferences[0].TargetFramework); Assert.Equal("This is a release note.", package.ReleaseNotes); }
// // ApplyReleases methods // List <string> installPackageToAppDir(UpdateInfo updateInfo, ReleaseEntry release) { var pkg = new ZipPackage(Path.Combine(rootAppDirectory, "packages", release.Filename)); var target = getDirectoryForRelease(release.Version); // NB: This might happen if we got killed partially through applying the release if (target.Exists) { Utility.DeleteDirectory(target.FullName); } target.Create(); // Copy all of the files out of the lib/ dirs in the NuGet package // into our target App directory. // // NB: We sort this list in order to guarantee that if a Net20 // and a Net40 version of a DLL get shipped, we always end up // with the 4.0 version. pkg.GetFiles().Where(x => pathIsInFrameworkProfile(x, appFrameworkVersion)).OrderBy(x => x.Path) .ForEach(x => { var targetPath = Path.Combine(target.FullName, Path.GetFileName(x.Path)); var fi = fileSystem.GetFileInfo(targetPath); if (fi.Exists) { fi.Delete(); } using (var inf = x.GetStream()) using (var of = fi.Open(FileMode.CreateNew, FileAccess.Write)) { log.Info("Writing {0} to app directory", targetPath); inf.CopyTo(of); } }); var newCurrentVersion = updateInfo.FutureReleaseEntry.Version; // Perform post-install; clean up the previous version by asking it // which shortcuts to install, and nuking them. Then, run the app's // post install and set up shortcuts. return(runPostInstallAndCleanup(newCurrentVersion, updateInfo.IsBootstrapping)); }
public void Merge(string secondNupkg, bool replaceMetadata = false) { var secondPackage = new ZipPackage(secondNupkg); if (replaceMetadata) { ReplaceMetadata(_Builder, secondPackage); } else { MergeMetadata(_Builder, secondPackage); } foreach (var packageFile in secondPackage.GetFiles()) { if (!_Builder.Files.Any(e => e.Path.Equals(packageFile.Path, StringComparison.OrdinalIgnoreCase))) { _Builder.Files.Add(packageFile); } } }
private void PrintVerbose(string outputPath) { Console.WriteLine(); var package = new ZipPackage(outputPath); Console.WriteLine("Id: {0}", package.Id); Console.WriteLine("Version: {0}", package.Version); Console.WriteLine("Authors: {0}", String.Join(", ", package.Authors)); Console.WriteLine("Description: {0}", package.Description); if (package.LicenseUrl != null) { Console.WriteLine("License Url: {0}", package.LicenseUrl); } if (package.ProjectUrl != null) { Console.WriteLine("Project Url: {0}", package.ProjectUrl); } if (!String.IsNullOrEmpty(package.Tags)) { Console.WriteLine("Tags: {0}", package.Tags.Trim()); } if (package.Dependencies.Any()) { Console.WriteLine("Dependencies: {0}", String.Join(", ", package.Dependencies.Select(d => d.ToString()))); } else { Console.WriteLine("Dependencies: None"); } Console.WriteLine(); foreach (var file in package.GetFiles().OrderBy(p => p.Path)) { Console.WriteLine(NuGetResources.PackageCommandAddedFile, file.Path); } Console.WriteLine(); }
public static void AssertContents(this ZipPackage package, params string[] files) { var actualFiles = package.GetFiles().Select(f => f.Path).ToDictionary(f => f, f => false, StringComparer.OrdinalIgnoreCase); var expectedFiles = files.ToDictionary(f => f, f => false, StringComparer.OrdinalIgnoreCase); foreach (var actualFile in actualFiles.Keys.ToList()) { if (expectedFiles.ContainsKey(actualFile)) { actualFiles[actualFile] = true; expectedFiles[actualFile] = true; } foreach (var expected in expectedFiles.Keys.ToList().Where(k => k.Contains("*"))) { var regex = Regex.Escape(expected).Replace("\\*", ".*"); if (Regex.IsMatch(actualFile, regex, RegexOptions.IgnoreCase)) { actualFiles[actualFile] = true; expectedFiles[expected] = true; } } } var unexpectedInPackage = actualFiles.Where(kvp => kvp.Value == false).Select(kvp => kvp.Key).ToList(); var missingInPackage = expectedFiles.Where(kvp => kvp.Value == false).Select(kvp => kvp.Key).ToList(); if (unexpectedInPackage.Any()) { Assert.Fail("These files were NOT expected to be in the package: " + Environment.NewLine + string.Join("," + Environment.NewLine, unexpectedInPackage.Select(u => "@\"" + u + "\""))); } if (missingInPackage.Any()) { Assert.Fail("These files were expected to be in the package: " + Environment.NewLine + string.Join("," + Environment.NewLine, missingInPackage.Select(u => "@\"" + u + "\""))); } }
public void CreatePackage(HttpContextBase context) { var request = context.Request; var stream = request.Files.Count > 0 ? request.Files[0].InputStream : request.InputStream; var clonedStream = CloneStream(stream); var package = new ZipPackage(clonedStream); // provide a cloned stream because ZipPackage now dispose it var symbolFiles = package.GetFiles("lib").Where(f => Path.GetExtension(f.Path) == ".pdb").ToList(); foreach (var symbolFile in symbolFiles) { ProcessSymbolFile(symbolFile, package); } if (IsSymbolPackage(package, symbolFiles)) { symbolPackageService.CreatePackage(context); } else { packageService.CreatePackage(context); } }
private void ProcessSymbolFile(IPackageFile symbolFile, ZipPackage package) { var tempSymbolFilePath = ExtractToSymbols(package, symbolFile); try { var referencedSources = symbolTools.GetSources(tempSymbolFilePath).ToList(); var sourceFiles = new HashSet <string>(package.GetFiles("src").Select(f => f.Path.ToLowerInvariant()).ToList()); if (referencedSources.Any() && sourceFiles.Any()) { var basePath = FindSourceBasePath(sourceFiles, referencedSources); if (basePath.Length != 0) { symbolTools.MapSources(package, tempSymbolFilePath, referencedSources, r => r.Substring(basePath.Length)); } } } finally { File.Delete(tempSymbolFilePath); } }
public static void AssertFileContent(this ZipPackage package, Dictionary <string, string> fileEntries) { var missmatches = new List <string>(); foreach (var fileEntry in fileEntries) { var file = package.GetFiles().FirstOrDefault(f => f.Path == fileEntry.Key); var content = new StreamReader(file.GetStream(), Encoding.UTF8).ReadToEnd(); if (fileEntry.Key.EndsWith(".xml") || fileEntry.Key.EndsWith(".config")) { content = content.ToXmlOneLine(); } if (content != fileEntry.Value) { missmatches.Add(file.Path); Trace.WriteLine("Missmatch in " + fileEntry.Key); Trace.WriteLine("IS:"); Trace.WriteLine(content + Environment.NewLine); Trace.WriteLine("SHOULD:"); Trace.WriteLine(fileEntry.Value); } else { Trace.WriteLine(fileEntry.Key + " OK"); } } if (missmatches.Any()) { Assert.Fail("These files have a missmatch: " + Environment.NewLine + string.Join("," + Environment.NewLine, missmatches)); } }
static int Main(params string[] args) { var cBase = Assembly.GetExecutingAssembly().CodeBase.Replace("file:///", "").Replace("/", "\\"); var fileName = cBase.Substring(cBase.LastIndexOf('\\') + 1); fileName = fileName.Substring(0, fileName.LastIndexOf('.')); Console.WriteLine("Package: " + fileName); bool uninstall = false; bool upgrade = false; string packageName = fileName; if (args.Length > 0) { switch (args[0]) { case "uninstall": uninstall = true; break; case "upgrade": upgrade = false; break; default: upgrade = true; break; } } if (string.IsNullOrWhiteSpace(packageName)) { return(-1); } IPackageRepository pr = PackageRepositoryFactory.Default.CreateRepository("http://192.168.0.17/Pietastic.WebUpdateService/nuget"); var latestVersion = pr.FindPackagesById(packageName).LastOrDefault(p => p.IsLatestVersion && p.Listed); if (latestVersion != null) { // Check if package is installed var packagePath = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), packageName ); if (uninstall) { Uninstall(packagePath); Process.GetCurrentProcess().Kill(); return(0); } Console.WriteLine("Creating App directory"); Console.WriteLine(packagePath); Directory.CreateDirectory(packagePath); var launcherFile = Path.Combine(packagePath, packageName + ".exe"); if (!System.IO.File.Exists(launcherFile)) { System.IO.File.Copy(cBase, launcherFile); } var programPackages = Path.Combine(packagePath, "packages"); Console.WriteLine("Creating Packages directory"); Console.WriteLine(programPackages); Directory.CreateDirectory(programPackages); var latestPackage = Path.Combine( programPackages, string.Format("{0}-{1}.nupkg", latestVersion.Id, latestVersion.Version.ToFullString()) ); var latestInstalled = Path.Combine( packagePath, string.Format("app-{0}", latestVersion.Version.ToFullString()) ); Console.WriteLine(latestInstalled); if (!System.IO.File.Exists(latestPackage)) { Console.WriteLine("Latest version not downloaded, removing old versions and downloading latest"); DirectoryInfo di = new DirectoryInfo(programPackages); var allPackages = di.EnumerateFiles("*.nupkg").ToList(); if (allPackages.Count > 0) { // Enumerate all packages, remove old packages, keep 3 latest var skipTheThreeLatest = allPackages.OrderByDescending(f => f.CreationTimeUtc).Skip(3); foreach (var pack in skipTheThreeLatest) { var appFolder = string.Format("app-{0}", pack.Name.Substring(pack.Name.LastIndexOf('-') + 1).Replace(".nupkg", "")); if (Directory.Exists(appFolder)) { Directory.Delete(Path.Combine(packagePath, appFolder), true); } } } using (var fs = latestVersion.GetStream()) { System.IO.File.WriteAllBytes(latestPackage, fs.ReadAllBytes()); } } string symLinkPath = string.Empty; Console.WriteLine("Installing latest version"); Directory.CreateDirectory(latestInstalled); var fz = new ZipPackage(latestPackage); foreach (var f in fz.GetFiles()) { var lFile = Path.Combine(latestInstalled, f.Path); if (System.IO.File.Exists(lFile)) { continue; } using (var fs = f.GetStream()) { System.IO.File.WriteAllBytes(lFile, fs.ReadAllBytes()); } if (f.Path == latestVersion.Id + ".exe") { Console.WriteLine("Modifying/Creating symlink"); symLinkPath = Path.Combine(packagePath, "app-" + f.Path); if (SymbolicLink.Exists(symLinkPath)) { System.IO.File.Delete(symLinkPath); } SymbolicLink.CreateFileLink(symLinkPath, lFile); Console.WriteLine(symLinkPath); } } var desktopShortcut = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.Desktop), (latestVersion.Title ?? packageName) + ".lnk" ); if (System.IO.File.Exists(desktopShortcut)) { System.IO.File.Delete(desktopShortcut); } CreateShortcut(desktopShortcut, launcherFile); Console.WriteLine(desktopShortcut); if (!upgrade) { ProcessStartInfo launch = new ProcessStartInfo(symLinkPath); var p = Process.Start(launch); p.WaitForExit(); Main("upgrade " + packageName); } return(0); } Console.WriteLine("Package: " + packageName + " was not found, please rename file"); return(1); }
private static bool IsSymbolPackage(ZipPackage package, IEnumerable <IPackageFile> symbolFiles) { return(symbolFiles.Any() && package.GetFiles("src").Any()); }
public override void ExecuteCommand() { Log.Trace("Getting latest packages..."); var packages = GetLatestStablePackages(); Log.Trace("Getting previously curated packages..."); var alreadyCuratedPackageIds = GetAlreadyCuratedPackageIds(); Log.Trace("Calculating minimum difference set..."); var packageIdsToCurate = packages.Keys.Except(alreadyCuratedPackageIds).ToList(); var totalCount = packageIdsToCurate.Count; var processedCount = 0; Log.Trace( "Curating {0} packages for the WebMatrix curated on '{1}',", totalCount, ConnectionString); Parallel.ForEach(packageIdsToCurate, new ParallelOptions { MaxDegreeOfParallelism = 10 }, packageIdToCurate => { var package = packages[packageIdToCurate]; try { var downloadPath = DownloadPackage(package); var nugetPackage = new ZipPackage(downloadPath); var shouldBeIncluded = nugetPackage.Tags != null && nugetPackage.Tags.ToLowerInvariant().Contains("aspnetwebpages"); if (!shouldBeIncluded) { shouldBeIncluded = true; foreach (var file in nugetPackage.GetFiles()) { var fi = new FileInfo(file.Path); if (fi.Extension == ".ps1" || fi.Extension == ".t4") { shouldBeIncluded = false; break; } } } if (shouldBeIncluded) { AddPackageToCuratedFeed(package); } File.Delete(downloadPath); Interlocked.Increment(ref processedCount); Log.Info( "{2} package '{0}.{1}' ({3} of {4}).", package.Id, package.Version, shouldBeIncluded ? "Curated" : "Ignored", processedCount, totalCount); } catch (Exception ex) { Interlocked.Increment(ref processedCount); Log.Error( "Error curating package '{0}.{1}' ({2} of {3}): {4}.", package.Id, package.Version, processedCount, totalCount, ex.Message); } }); }
public void PackageBuilderWorksWithFileNamesContainingSpecialCharacters() { // Arrange var fileNames = new[] { @"lib\regular.file.dll", @"lib\name with spaces.dll", @"lib\C#\test.dll", @"content\images\logo123?#78.png", @"content\images\bread&butter.jpg", }; // Act var builder = new PackageBuilder { Id = "test", Version = new SemanticVersion("1.0"), Description = "test" }; builder.Authors.Add("test"); foreach (var name in fileNames) { builder.Files.Add(CreatePackageFile(name)); } // Assert using (MemoryStream stream = new MemoryStream()) { builder.Save(stream); var zipPackage = new ZipPackage(() => new MemoryStream(stream.ToArray()), enableCaching: false); Assert.Equal(@"content\images\bread&butter.jpg", zipPackage.GetFiles().ElementAt(0).Path); Assert.Equal(@"content\images\logo123?#78.png", zipPackage.GetFiles().ElementAt(1).Path); Assert.Equal(@"lib\C#\test.dll", zipPackage.GetFiles().ElementAt(2).Path); Assert.Equal(@"lib\name with spaces.dll", zipPackage.GetFiles().ElementAt(3).Path); Assert.Equal(@"lib\regular.file.dll", zipPackage.GetFiles().ElementAt(4).Path); } }
private async Task CalculateValidity(IReadOnlyList <PackageFile> files) { var filesWithPdb = (from pf in files let ext = Path.GetExtension(pf.Path) where ".dll".Equals(ext, StringComparison.OrdinalIgnoreCase) || ".exe".Equals(ext, StringComparison.OrdinalIgnoreCase) || ".winmd".Equals(ext, StringComparison.OrdinalIgnoreCase) select new FileWithPdb { Primary = pf, Pdb = pf.GetAssociatedFiles().FirstOrDefault(af => ".pdb".Equals(Path.GetExtension(af.Path), StringComparison.OrdinalIgnoreCase)) }) .ToList(); var sourceLinkErrors = new List <(PackageFile file, string errors)>(); var noSourceLink = new List <PackageFile>(); var noSymbols = new List <FileWithDebugData>(); var untrackedSources = new List <FileWithDebugData>(); var nonDeterministic = new List <PackageFile>(); var allFilePaths = filesWithPdb.ToDictionary(pf => pf.Primary.Path); var pdbChecksumValid = true; foreach (var file in filesWithPdb.ToArray()) // work on array as we'll remove items that are satellite assemblies as we go { // Skip satellite assemblies if (IsSatelliteAssembly(file.Primary.Path)) { filesWithPdb.Remove(allFilePaths[file.Primary.Path]); continue; } // If we have a PDB, try loading that first. If not, may be embedded. // Local checks first if (file.Pdb != null) { var filePair = new FileWithDebugData(file.Primary, null); if (!ValidatePdb(filePair, file.Pdb.GetStream(), noSourceLink, sourceLinkErrors, untrackedSources, nonDeterministic)) { pdbChecksumValid = false; noSymbols.Add(filePair); } } else // No PDB, see if it's embedded { try { using var str = file.Primary.GetStream(); using var tempFile = new TemporaryFile(str); var assemblyMetadata = AssemblyMetadataReader.ReadMetaData(tempFile.FileName); if (assemblyMetadata?.DebugData.HasDebugInfo == true) { // we have an embedded pdb if (!assemblyMetadata.DebugData.HasSourceLink) { noSourceLink.Add(file.Primary); } if (assemblyMetadata.DebugData.SourceLinkErrors.Count > 0) { // Has source link errors sourceLinkErrors.Add((file.Primary, string.Join("\n", assemblyMetadata.DebugData.SourceLinkErrors))); } // Check for non-embedded sources if (assemblyMetadata.DebugData.UntrackedSources.Count > 0) { var filePair = new FileWithDebugData(file.Primary, assemblyMetadata.DebugData); untrackedSources.Add(filePair); } // Check for deterministic sources if (!assemblyMetadata.DebugData.SourcesAreDeterministic) { nonDeterministic.Add(file.Primary); } } else // no embedded pdb, try to look for it elsewhere { noSymbols.Add(new FileWithDebugData(file.Primary, assemblyMetadata?.DebugData)); } } catch // an error occured, no symbols { noSymbols.Add(new FileWithDebugData(file.Primary, null)); } } } var requireExternal = false; // See if any pdb's are missing and check for a snupkg on NuGet.org. if (noSymbols.Count > 0 && _publishedOnNuGetOrg) { // try to get on NuGet.org // https://www.nuget.org/api/v2/symbolpackage/Newtonsoft.Json/12.0.3 -- Will redirect try { #pragma warning disable CA2234 // Pass system uri objects instead of strings var response = await _httpClient.GetAsync($"https://www.nuget.org/api/v2/symbolpackage/{_package.Id}/{_package.Version.ToNormalizedString()}").ConfigureAwait(false); #pragma warning restore CA2234 // Pass system uri objects instead of strings if (response.IsSuccessStatusCode) // we'll get a 404 if none { requireExternal = true; using var getStream = await response.Content.ReadAsStreamAsync(); using var tempFile = new TemporaryFile(getStream, ".snupkg"); using var package = new ZipPackage(tempFile.FileName); // Look for pdb's for the missing files var dict = package.GetFiles().ToDictionary(k => k.Path); foreach (var file in noSymbols.ToArray()) // from a copy so we can remove as we go { // file to look for var pdbpath = Path.ChangeExtension(file.File.Path, ".pdb"); if (dict.TryGetValue(pdbpath, out var pdbfile)) { // Validate if (ValidatePdb(file, pdbfile.GetStream(), noSourceLink, sourceLinkErrors, untrackedSources, nonDeterministic)) { noSymbols.Remove(file); } else { pdbChecksumValid = false; } } } } } catch // Could not check, leave status as-is { } } // Check for Microsoft assemblies on the Microsoft symbol server if (noSymbols.Count > 0) { var microsoftFiles = noSymbols.Where(f => f.DebugData != null && IsMicrosoftFile(f.File)).ToList(); foreach (var file in microsoftFiles) { var pdbStream = await GetSymbolsAsync(file.DebugData !.SymbolKeys); if (pdbStream != null) { requireExternal = true; // Found a PDB for it if (ValidatePdb(file, pdbStream, noSourceLink, sourceLinkErrors, untrackedSources, nonDeterministic)) { noSymbols.Remove(file); } else { pdbChecksumValid = false; } } } } if (noSymbols.Count == 0 && noSourceLink.Count == 0 && sourceLinkErrors.Count == 0) { if (untrackedSources.Count > 0) { SourceLinkResult = SymbolValidationResult.HasUntrackedSources; var sb = new StringBuilder("Contains untracked sources:\n"); sb.AppendLine("To Fix:"); sb.AppendLine("<EmbedUntrackedSources>true</EmbedUntrackedSources>"); foreach (var untracked in untrackedSources) { sb.AppendLine($"Assembly: {untracked.File.Path}"); foreach (var source in untracked.DebugData !.UntrackedSources) { sb.AppendLine($" {source}"); } sb.AppendLine(); } SourceLinkErrorMessage = sb.ToString(); } else if (filesWithPdb.Count == 0) { SourceLinkResult = SymbolValidationResult.NothingToValidate; SourceLinkErrorMessage = "No files found to validate"; } else if (requireExternal) { SourceLinkResult = SymbolValidationResult.ValidExternal; SourceLinkErrorMessage = null; } else { SourceLinkResult = SymbolValidationResult.Valid; SourceLinkErrorMessage = null; } } else { var found = false; var sb = new StringBuilder(); if (noSourceLink.Count > 0) { SourceLinkResult = SymbolValidationResult.NoSourceLink; sb.AppendLine($"Missing Source Link for:\n{string.Join("\n", noSourceLink.Select(p => p.Path)) }"); found = true; } if (sourceLinkErrors.Count > 0) { SourceLinkResult = SymbolValidationResult.InvalidSourceLink; if (found) { sb.AppendLine(); } foreach (var(file, errors) in sourceLinkErrors) { sb.AppendLine($"Source Link errors for {file.Path}:\n{string.Join("\n", errors) }"); } found = true; } if (noSymbols.Count > 0) // No symbols "wins" as it's more severe { SourceLinkResult = SymbolValidationResult.NoSymbols; if (found) { sb.AppendLine(); } if (!pdbChecksumValid) { sb.AppendLine("Some PDB's checksums do not match their PE files and are shown as missing."); } sb.AppendLine($"Missing Symbols for:\n{string.Join("\n", noSymbols.Select(p => p.File.Path)) }"); } SourceLinkErrorMessage = sb.ToString(); } if (SourceLinkResult == SymbolValidationResult.NothingToValidate) { DeterministicResult = DeterministicResult.NothingToValidate; DeterministicErrorMessage = null; } else if (SourceLinkResult == SymbolValidationResult.NoSymbols) { DeterministicResult = DeterministicResult.NonDeterministic; DeterministicErrorMessage = "Missing Symbols"; } else if (nonDeterministic.Count > 0) { DeterministicResult = DeterministicResult.NonDeterministic; var sb = new StringBuilder(); sb.AppendLine("Ensure that the following properties are enabled for CI builds\nand you're using at least the 2.1.300 SDK:"); sb.AppendLine("<Deterministic>true</Deterministic>"); sb.AppendLine("<ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>"); sb.AppendLine(); sb.AppendLine("The following assemblies have not been compiled with deterministic settings:"); foreach (var file in nonDeterministic) { sb.AppendLine(file.Path); } DeterministicErrorMessage = sb.ToString(); } else if (SourceLinkResult == SymbolValidationResult.HasUntrackedSources) { DeterministicResult = DeterministicResult.HasUntrackedSources; DeterministicErrorMessage = null; } else { DeterministicResult = DeterministicResult.Valid; DeterministicErrorMessage = null; } }
private void PrintVerbose(string outputPath) { Console.WriteLine(); var package = new ZipPackage(outputPath); Console.WriteLine("Id: {0}", package.Id); Console.WriteLine("Version: {0}", package.Version); Console.WriteLine("Authors: {0}", String.Join(", ", package.Authors)); Console.WriteLine("Description: {0}", package.Description); if (package.LicenseUrl != null) { Console.WriteLine("License Url: {0}", package.LicenseUrl); } if (package.ProjectUrl != null) { Console.WriteLine("Project Url: {0}", package.ProjectUrl); } if (!String.IsNullOrEmpty(package.Tags)) { Console.WriteLine("Tags: {0}", package.Tags.Trim()); } if (package.DependencySets.Any()) { Console.WriteLine("Dependencies: {0}", String.Join(", ", package.DependencySets.SelectMany(d => d.Dependencies).Select(d => d.ToString()))); } else { Console.WriteLine("Dependencies: None"); } Console.WriteLine(); foreach (var file in package.GetFiles().OrderBy(p => p.Path)) { Console.WriteLine(NuGetResources.PackageCommandAddedFile, file.Path); } Console.WriteLine(); }
public Stream OpenPackageSourceFile(IPackageName package, string relativePath) { relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar); // Try to return the source file from its uncompressed location var parts = new[] { package.Id, package.Version.ToString(), "src", relativePath }; var stream = OpenFile(Path.Combine(parts)); if (stream != null) return stream; // If the file wasn't found uncompressed look for it in symbol package zip file var packagePath = GetNupkgPath(package); if (!File.Exists(packagePath)) return null; var srcPath = Path.Combine("src", relativePath); var packageFile = new ZipPackage(packagePath); var file = packageFile.GetFiles().SingleOrDefault(f => f.Path.Equals(srcPath, StringComparison.InvariantCultureIgnoreCase)); return file != null ? file.GetStream() : null; }
public bool ImportPage(byte[] uploadedPackage, string fileName, int pageId, int siteId) { // Write .nupkg file to the PackageStaging folder... var path = Path.Combine(HttpContext.Current.Server.MapPath("~/App_Data/PackageStaging"), fileName); using (var file = new FileStream(path, FileMode.Create)) { file.Write(uploadedPackage, 0, uploadedPackage.Length); } var package = new ZipPackage(path); var packageFiles = package.GetFiles().ToList(); var exportFile = packageFiles.FirstOrDefault(f => f.Path.Contains("export.json")); Page page = null; // If export.json is present, deserialize data // * Are there any new BlockTypes to register? If so, save them first. // * Scrub out any `Id` and `Guid` fields that came over from export // * Save page data via PageService if (exportFile != null) { string json; using (var stream = exportFile.GetStream()) { json = stream.ReadToEnd(); } page = Page.FromJson(json); } // Validate package... // + Does it have any executable .dll files? Should those go to the bin folder, or into a plugins directory to be loaded via MEF? // - Does it have code or asset files that need to go on the file system? (Done) // - Does it have an export.json file? Should that be a requirement? (Done) // + Does it have any corresponding SQL, migrations, seed methods to run, etc. if (page != null) { var rockContext = new RockContext(); // Find new block types and save them prior to scrubbing data... var newBlockTypes = FindNewBlockTypes(page, new BlockTypeService(rockContext).Queryable()).ToList(); rockContext.WrapTransaction(() => { try { var blockTypeService = new BlockTypeService(rockContext); foreach (var blockType in newBlockTypes) { blockTypeService.Add(blockType); } rockContext.SaveChanges(); ValidateImportData(page, newBlockTypes); SavePages(rockContext, page, newBlockTypes, pageId, siteId); ExpandFiles(packageFiles); } catch (Exception e) { ErrorMessages.Add(e.Message); } }); // Clean up PackageStaging folder on successful import. var file = new FileInfo(path); file.Delete(); return(ErrorMessages.Count <= 0); } ErrorMessages.Add("The export package uploaded does not appear to have any data associated with it."); return(false); }
public void CreateDeltaPackageIntegrationTest() { var basePackage = IntegrationTestHelper.GetPath("fixtures", "Squirrel.Tests.0.1.0-pre.nupkg"); var newPackage = IntegrationTestHelper.GetPath("fixtures", "Squirrel.Tests.0.2.0-pre.nupkg"); var sourceDir = IntegrationTestHelper.GetPath("fixtures", "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(); var deltaBuilder = new DeltaPackageBuilder(); deltaBuilder.CreateDeltaPackage(baseFixture, fixture, tempFiles[2]); var fullPkg = new ZipPackage(tempFiles[1]); var deltaPkg = new ZipPackage(tempFiles[2]); // // Package Checks // fullPkg.Id.ShouldEqual(deltaPkg.Id); fullPkg.Version.CompareTo(deltaPkg.Version).ShouldEqual(0); // 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); // // File Checks /// var deltaPkgFiles = deltaPkg.GetFiles().ToList(); deltaPkgFiles.Count.ShouldBeGreaterThan(0); this.Log().Info("Files in delta package:"); deltaPkgFiles.ForEach(x => this.Log().Info(x.Path)); var newFilesAdded = new[] { "Newtonsoft.Json.dll", "Refit.dll", "Refit-Portable.dll", "Castle.Core.dll", }.Select(x => x.ToLowerInvariant()); // vNext adds a dependency on Refit newFilesAdded .All(x => deltaPkgFiles.Any(y => y.Path.ToLowerInvariant().Contains(x))) .ShouldBeTrue(); // All the other files should be diffs and shasums deltaPkgFiles .Where(x => !newFilesAdded.Any(y => x.Path.ToLowerInvariant().Contains(y))) .All(x => x.Path.ToLowerInvariant().EndsWith("diff") || x.Path.ToLowerInvariant().EndsWith("shasum")) .ShouldBeTrue(); // Every .diff file should have a shasum file deltaPkg.GetFiles().Any(x => x.Path.ToLowerInvariant().EndsWith(".diff")).ShouldBeTrue(); deltaPkg.GetFiles() .Where(x => x.Path.ToLowerInvariant().EndsWith(".diff")) .ForEach(x => { var lookingFor = x.Path.Replace(".diff", ".shasum"); this.Log().Info("Looking for corresponding shasum file: {0}", lookingFor); deltaPkg.GetFiles().Any(y => y.Path == lookingFor).ShouldBeTrue(); }); } finally { tempFiles.ForEach(File.Delete); } }