public static ManifestMetadata ReadMetadata(string path) { var document = XDocument.Load(path); var xElement = document.Root.ElementsNoNamespace("metadata").FirstOrDefault(); var manifestMetadata = new ManifestMetadata { DependencySets = new List<ManifestDependencySet>(), ReferenceSets = new List<ManifestReferenceSet>(), MinClientVersionString = xElement.GetOptionalAttributeValue("minClientVersion") }; var allElements = new HashSet<string>(); for (var node = xElement.FirstNode; node != null; node = node.NextNode) { var element = node as XElement; if (element != null) { ReadMetadataValue(manifestMetadata, element, allElements); } } foreach (string str in RequiredElements) { if (!allElements.Contains(str)) { throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, "", new object[] { str })); } } return manifestMetadata; }
public string GenerateSingleCustomPackage(PackageDefinition definition, string binFolderPath, string outputFolderPath, string releaseVersion, IEnumerable<string> singleDLLPackages, IEnumerable<string> customPackages, string packageNamePrefix) { // if no dependencies exist, don't create package from definition IEnumerable<ManifestDependency> dependencies = this.GenerateDependencies(definition.Dependencies, binFolderPath, releaseVersion, singleDLLPackages, customPackages, packageNamePrefix); if (!dependencies.Any()) { return String.Empty; } // Create nupkg file var packageId = packageNamePrefix + definition.Id + "." + releaseVersion; var nugetFilePath = Path.Combine(outputFolderPath, packageId + ".nupkg"); var metadata = new ManifestMetadata { Id = packageNamePrefix + definition.Id, Title = packageNamePrefix + definition.Id, Version = releaseVersion, Tags = definition.Tag, Authors = "Sitecore", Owners = "Sitecore", Description = definition.Description, RequireLicenseAcceptance = false, IconUrl = "http://www.sitecore.net/favicon.ico", DependencySets = new List<ManifestDependencySet> { new ManifestDependencySet { Dependencies = dependencies.ToList() } } }; var builder = new PackageBuilder(); builder.Populate(metadata); using (FileStream stream = File.Open(nugetFilePath, FileMode.OpenOrCreate)) { builder.Save(stream); } return nugetFilePath; }
public virtual void ApplyTo(ManifestMetadata metadata) { metadata.Title = Title; metadata.Authors = Authors; metadata.Copyright = Copyright; metadata.Description = Description; metadata.IconUrl = IconUrl; metadata.LicenseUrl = LicenseUrl; metadata.ProjectUrl = ProjectUrl; metadata.ReleaseNotes = ReleaseNotes; metadata.RequireLicenseAcceptance = RequiresLicenseAcceptance; metadata.Summary = Summary; metadata.Tags = Tags; }
public void ProjectFactoryInitializesPropertiesForPreprocessor() { // arrange const string inputSpec = @"<?xml version=""1.0""?> <package> <metadata> <id>$id$</id> <version>$version$</version> <description>$description$</description> <authors>$author$</authors> <copyright>$copyright$</copyright> <licenseUrl>http://nuget.codeplex.com/license</licenseUrl> <projectUrl>http://nuget.codeplex.com</projectUrl> <tags>nuget</tags> </metadata> </package>"; var metadata = new ManifestMetadata { Id = "ProjectFactoryTest", Version = "2.0.30619.9000", Title = "NuGet.Test", Description = "", Copyright = "\x00a9 Outercurve. All rights reserved.", Authors = "Outercurve Foundation", }; var projectMock = new Mock<Project>(); var factory = new ProjectFactory(projectMock.Object); // act var author = factory.InitializeProperties(metadata); var actual = Preprocessor.Process(inputSpec.AsStream(), factory, false); // assert Assert.Equal("Outercurve Foundation", author); const string expected = @"<?xml version=""1.0""?> <package> <metadata> <id>ProjectFactoryTest</id> <version>2.0.30619.9000</version> <description></description> <authors>Outercurve Foundation</authors> <copyright>© Outercurve. All rights reserved.</copyright> <licenseUrl>http://nuget.codeplex.com/license</licenseUrl> <projectUrl>http://nuget.codeplex.com</projectUrl> <tags>nuget</tags> </metadata> </package>"; Assert.Equal(expected, actual); }
public void GetManifestVersionReturns1IfNoNewPropertiesAreSet() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description" }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(1, version); }
public void GetManifestVersionReturns2IfCopyrightIsSet() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description", Copyright = "© Outercurve Foundation" }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(2, version); }
public void GetManifestVersionReturns1IfFrameworkAssemblyHasValues() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description", FrameworkAssemblies = new List<ManifestFrameworkAssembly> { new ManifestFrameworkAssembly { AssemblyName = "System.Data.dll" } } }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(1, version); }
public void BuildPackage(string basePath, IList<string> includes, ManifestMetadata metadata, string outFolder, bool overwrite) { var nugetPkgBuilder = new PackageBuilder(); nugetPkgBuilder.PopulateFiles(basePath, includes.Select(i => new ManifestFile { Source = i })); nugetPkgBuilder.Populate(metadata); var filename = metadata.Id + "." + metadata.Version + ".nupkg"; var output = Path.Combine(outFolder, filename); if (fileSystem.FileExists(output) && !overwrite) throw new CommandException("The package file already exists and --overwrite was not specified"); log.Information("Saving {Filename} to {OutFolder}...", filename, outFolder); fileSystem.EnsureDirectoryExists(outFolder); using (var outStream = fileSystem.OpenFile(output, FileMode.Create)) nugetPkgBuilder.Save(outStream); }
public void BuildPackage(string basePath, IList<string> includes, ManifestMetadata metadata, string outFolder, bool overwrite) { var filename = metadata.Id + "." + metadata.Version + ".zip"; var output = fileSystem.GetFullPath(Path.Combine(outFolder, filename)); if (fileSystem.FileExists(output) && !overwrite) throw new CommandException("The package file already exists and --overwrite was not specified"); log.Information("Saving {Filename} to {OutFolder}...", filename, outFolder); fileSystem.EnsureDirectoryExists(outFolder); var basePathLength = fileSystem.GetFullPath(basePath).Length; using (var stream = fileSystem.OpenFile(output, FileAccess.Write)) using (var archive = new ZipArchive(stream, ZipArchiveMode.Create)) { foreach (var pattern in includes) { log.Debug("Adding files from {Path} matching pattern {Pattern}", basePath, pattern); foreach (var file in PathResolver.PerformWildcardSearch(basePath, pattern)) { var fullFilePath = fileSystem.GetFullPath(file); if (string.Equals(fullFilePath, output, StringComparison.CurrentCultureIgnoreCase)) continue; var relativePath = UseCrossPlatformDirectorySeparator( fullFilePath.Substring(basePathLength).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)); log.Debug("Adding file: {Path}", relativePath); var entry = archive.CreateEntry(relativePath, CompressionLevel.Optimal); entry.LastWriteTime = new DateTimeOffset(new FileInfo(file).LastWriteTime); using (var entryStream = entry.Open()) using (var sourceStream = File.OpenRead(file)) { sourceStream.CopyTo(entryStream); } } } } }
public void GetManifestVersionReturns2IfFrameworkAssemblyAndReferencesAreSet() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description", FrameworkAssemblies = new List<ManifestFrameworkAssembly> { new ManifestFrameworkAssembly { AssemblyName = "System.Data.dll" } }, References = new List<ManifestReference> { new ManifestReference { File = "Foo.dll" } } }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(2, version); }
private bool PublishProject() { try { string[] scriptFiles = Directory.GetFiles(_projectPath, "*.*", SearchOption.AllDirectories); List <ManifestContentFiles> manifestFiles = new List <ManifestContentFiles>(); foreach (string file in scriptFiles) { ManifestContentFiles manifestFile = new ManifestContentFiles { Include = file.Replace(_projectPath, "") }; manifestFiles.Add(manifestFile); } ManifestMetadata metadata = new ManifestMetadata() { Id = _projectName.Replace(" ", "_"), Title = _projectName, Authors = txtAuthorName.Text.Trim(), Version = txtVersion.Text.Trim(), Description = txtDescription.Text.Trim(), RequireLicenseAcceptance = false, IconUrl = "https://openbots.ai/wp-content/uploads/2020/11/Studio-Icon-256px.png", DependencySets = new List <ManifestDependencySet>() { new ManifestDependencySet() { Dependencies = new List <ManifestDependency>() { new ManifestDependency() { Id = "OpenBots.Studio", Version = new Version(Application.ProductVersion).ToString() }, } } }, ContentFiles = manifestFiles, }; foreach (var dependency in _projectDependencies) { var dep = new ManifestDependency { Id = dependency.Key, Version = dependency.Value }; metadata.DependencySets[0].Dependencies.Add(dep); } PackageBuilder builder = new PackageBuilder(); builder.PopulateFiles(_projectPath, new[] { new ManifestFile() { Source = "**" } }); builder.Populate(metadata); if (!Directory.Exists(txtLocation.Text)) { Directory.CreateDirectory(txtLocation.Text); } string nugetFilePath = Path.Combine(txtLocation.Text.Trim(), $"{_projectName}_{txtVersion.Text.Trim()}.nupkg"); using (FileStream stream = File.Open(nugetFilePath, FileMode.OpenOrCreate)) builder.Save(stream); NotificationMessage = $"'{_projectName}' published successfully"; if (cbxLocation.Text == "Local Only") { return(true); } try { lblError.Text = $"Publishing {_projectName} to the server..."; var client = AuthMethods.GetAuthToken(); AutomationMethods.UploadAutomation(client, _projectName, nugetFilePath, _automationEngine); } catch (Exception) { NotificationMessage = $"'{_projectName}' was published locally. To publish to an OpenBots Server please install and connect the OpenBots Agent."; } return(true); } catch (Exception ex) { lblError.Text = ex.Message; return(false); } }
public void ReadFromReadsAllMetadataValues() { var references = new List <PackageReferenceSet> { new PackageReferenceSet( (NuGetFramework)null, new [] { "Test.dll" } ), new PackageReferenceSet( NuGetFramework.Parse("hello"), new [] { "world.winmd" } ) }; // Arrange var manifestStream = CreateManifest( id: "Test-Pack2", version: "1.0.0-alpha", title: "blah", authors: "Outercurve", licenseUrl: "http://nuget.org/license", projectUrl: "http://nuget.org/project", iconUrl: "https://nuget.org/icon", requiresLicenseAcceptance: true, developmentDependency: true, description: "This is not a description", summary: "This is a summary", releaseNotes: "Release notes", copyright: "Copyright 2012", language: "fr-FR", tags: "Test Unit", dependencies: new[] { new PackageDependency("Test", VersionRange.Parse("1.2.0")) }, assemblyReference: new[] { new FrameworkAssemblyReference("System.Data", new[] { NuGetFramework.Parse("4.0") }) }, references: references, serviceable: true, packageTypes: new[] { new PackageType("foo", new Version(2, 0, 0)), new PackageType("bar", new Version(0, 0)) }, minClientVersion: "2.0.1.0" ); var manifestMetadata = new ManifestMetadata { Id = "Test-Pack2", Version = NuGetVersion.Parse("1.0.0-alpha"), Description = "This is not a description", Authors = new[] { "Outercurve" }, RequireLicenseAcceptance = true, DevelopmentDependency = true, Summary = "This is a summary", ReleaseNotes = "Release notes", Copyright = "Copyright 2012", Language = "fr-FR", Tags = "Test Unit", Serviceable = true, DependencyGroups = new[] { new PackageDependencyGroup( NuGetFramework.AnyFramework, new [] { new PackageDependency("Test", VersionRange.Parse("1.2.0")) } ) }, FrameworkReferences = new[] { new FrameworkAssemblyReference("System.Data", new [] { NuGetFramework.Parse("4.0") } ) }, PackageAssemblyReferences = new[] { new PackageReferenceSet( (NuGetFramework)null, new [] { "Test.dll" } ), new PackageReferenceSet( NuGetFramework.Parse("hello"), new [] { "world.winmd" } ) }, PackageTypes = new[] { new PackageType("foo", new Version(2, 0, 0)), new PackageType("bar", new Version(0, 0)) }, MinClientVersionString = "2.0.1.0", }; manifestMetadata.SetLicenseUrl("http://nuget.org/license"); manifestMetadata.SetProjectUrl("http://nuget.org/project"); manifestMetadata.SetIconUrl("https://nuget.org/icon"); var expectedManifest = new Manifest(manifestMetadata); // Act var manifest = Manifest.ReadFrom(manifestStream, validateSchema: true); // Assert AssertManifest(expectedManifest, manifest); }
private string CreateNugget() { var csproj = Path.GetFullPath(Path.Combine(ClientDirectory, "LIC.Malone.Client.Desktop.csproj")); var bin = Path.GetFullPath(Path.Combine(ClientDirectory, "bin", "Release")); var buildDirectoryInfo = Directory.CreateDirectory(BuildDirectory); Directory.SetCurrentDirectory(buildDirectoryInfo.FullName); Clean(buildDirectoryInfo); // Rely on standard nuget process to build the project and create a starting package to copy metadata from. StartProcess("nuget.exe", string.Format("pack {0} -Build -Prop Configuration=Release", csproj)); var nupkg = buildDirectoryInfo.GetFiles("*.nupkg").Single(); var package = new ZipPackage(nupkg.FullName); // Copy all of the metadata *EXCEPT* for dependencies. Kill those. var manifest = new ManifestMetadata { Id = package.Id, Version = package.Version.ToString(), Authors = string.Join(", ", package.Authors), Copyright = package.Copyright, DependencySets = null, Description = package.Description, Title = package.Title, IconUrl = package.IconUrl.ToString(), ProjectUrl = package.ProjectUrl.ToString(), LicenseUrl = package.LicenseUrl.ToString() }; const string target = @"lib\net45"; // Include dependencies in the package. var files = new List <ManifestFile> { new ManifestFile { Source = "*.dll", Target = target }, new ManifestFile { Source = "Malone.exe", Target = target }, new ManifestFile { Source = "Malone.exe.config", Target = target }, }; var builder = new PackageBuilder(); builder.Populate(manifest); builder.PopulateFiles(bin, files); var nugget = Path.Combine(buildDirectoryInfo.FullName, nupkg.Name); using (var stream = File.Open(nugget, FileMode.OpenOrCreate)) { builder.Save(stream); } return(nugget); }
public static XElement ToXElement(this ManifestMetadata metadata, XNamespace ns, bool generateBackwardsCompatible = true) { var elem = new XElement(ns + "metadata"); if (metadata.MinClientVersionString != null) { elem.SetAttributeValue("minClientVersion", metadata.MinClientVersionString); } elem.Add(new XElement(ns + "id", metadata.Id)); AddElementIfNotNull(elem, ns, "version", metadata.Version?.ToFullString()); AddElementIfNotNull(elem, ns, "title", metadata.Title); if (!metadata.PackageTypes.Contains(PackageType.SymbolsPackage)) { AddElementIfNotNull(elem, ns, "authors", metadata.Authors, authors => string.Join(",", authors)); AddElementIfNotNull(elem, ns, "owners", metadata.Owners, owners => string.Join(",", owners)); } if (metadata.DevelopmentDependency) { elem.Add(new XElement(ns + "developmentDependency", metadata.DevelopmentDependency)); } if (!metadata.PackageTypes.Contains(PackageType.SymbolsPackage)) { elem.Add(new XElement(ns + "requireLicenseAcceptance", metadata.RequireLicenseAcceptance)); var licenseUrlToWrite = metadata.LicenseUrl?.ToString(); if (metadata.LicenseMetadata != null) { var licenseElement = GetXElementFromLicenseMetadata(ns, metadata.LicenseMetadata); if (licenseElement != null) { elem.Add(licenseElement); } if (generateBackwardsCompatible) { licenseUrlToWrite = metadata.LicenseMetadata.LicenseUrl.OriginalString; } } AddElementIfNotNull(elem, ns, "licenseUrl", licenseUrlToWrite); AddElementIfNotNull(elem, ns, "icon", metadata.Icon); } AddElementIfNotNull(elem, ns, "projectUrl", metadata.ProjectUrl); AddElementIfNotNull(elem, ns, "iconUrl", metadata.IconUrl); AddElementIfNotNull(elem, ns, "description", metadata.Description); AddElementIfNotNull(elem, ns, "summary", metadata.Summary); AddElementIfNotNull(elem, ns, "releaseNotes", metadata.ReleaseNotes); AddElementIfNotNull(elem, ns, "copyright", metadata.Copyright); AddElementIfNotNull(elem, ns, "language", metadata.Language); AddElementIfNotNull(elem, ns, "tags", metadata.Tags); if (metadata.Serviceable) { elem.Add(new XElement(ns + "serviceable", metadata.Serviceable)); } if (metadata.PackageTypes != null && metadata.PackageTypes.Any()) { elem.Add(GetXElementFromManifestPackageTypes(ns, metadata.PackageTypes)); } if (metadata.Repository != null) { var repoElement = GetXElementFromManifestRepository(ns, metadata.Repository); if (repoElement != null) { elem.Add(repoElement); } } elem.Add(GetXElementFromGroupableItemSets( ns, metadata.DependencyGroups, set => set.TargetFramework.IsSpecificFramework || set.Packages.Any(dependency => dependency.Exclude.Count > 0 || dependency.Include.Count > 0), set => set.TargetFramework.IsSpecificFramework ? set.TargetFramework.GetFrameworkString() : null, set => set.Packages, GetXElementFromPackageDependency, Dependencies, TargetFramework)); elem.Add(GetXElementFromGroupableItemSets( ns, metadata.PackageAssemblyReferences, set => set.TargetFramework?.IsSpecificFramework == true, set => set.TargetFramework?.GetFrameworkString(), set => set.References, GetXElementFromPackageReference, References, TargetFramework)); elem.Add(GetXElementFromGroupableItemSets( ns: ns, objectSets: metadata.FrameworkReferenceGroups, isGroupable: set => true, // the TFM is required for framework references getGroupIdentifer: set => set.TargetFramework.GetFrameworkString(), getItems: set => set.FrameworkReferences, getXElementFromItem: GetXElementFromFrameworkReference, parentName: NuspecUtility.FrameworkReferences, identifierAttributeName: TargetFramework)); elem.Add(GetXElementFromFrameworkAssemblies(ns, metadata.FrameworkReferences)); elem.Add(GetXElementFromManifestContentFiles(ns, metadata.ContentFiles)); return(elem); }
public static XElement ToXElement(this ManifestMetadata metadata, XNamespace ns) { return(ToXElement(metadata, ns, generateBackwardsCompatible: true)); }
private bool PublishProject() { try { string[] scriptFiles = Directory.GetFiles(_projectPath, "*.json", SearchOption.AllDirectories); List <ManifestContentFiles> manifestFiles = new List <ManifestContentFiles>(); foreach (string file in scriptFiles) { ManifestContentFiles manifestFile = new ManifestContentFiles { Include = file.Replace(_projectPath, "") }; manifestFiles.Add(manifestFile); } ManifestMetadata metadata = new ManifestMetadata() { Id = _projectId.ToString(), Title = _projectName, Authors = txtAuthorName.Text.Trim(), Version = txtVersion.Text.Trim(), Description = txtDescription.Text.Trim(), RequireLicenseAcceptance = false, DependencySets = new List <ManifestDependencySet>() { new ManifestDependencySet() { Dependencies = new List <ManifestDependency>() { new ManifestDependency() { Id = "OpenBots.Studio", Version = new Version(Application.ProductVersion).ToString() } } } }, ContentFiles = manifestFiles, }; PackageBuilder builder = new PackageBuilder(); builder.PopulateFiles(_projectPath, new[] { new ManifestFile() { Source = "**" } }); builder.Populate(metadata); if (!Directory.Exists(txtLocation.Text)) { Directory.CreateDirectory(txtLocation.Text); } string nugetFilePath = Path.Combine(txtLocation.Text.Trim(), $"{_projectName}_{txtVersion.Text.Trim()}.nupkg"); using (FileStream stream = File.Open(nugetFilePath, FileMode.OpenOrCreate)) builder.Save(stream); NotificationMessage = $"'{_projectName}' published successfully"; try { lblError.Text = $"Publishing {_projectName} to the server..."; var client = AuthMethods.GetAuthToken(); ProcessMethods.UploadProcess(client, _projectName, nugetFilePath); } catch (Exception) { NotificationMessage = $"'{_projectName}' was published locally. To publish to an OpenBots Server please install and connect the OpenBots Agent."; } return(true); } catch (Exception ex) { lblError.Text = ex.Message; return(false); } }
public void GetManifestVersionIgnoresEmptyStrings() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description", ReleaseNotes = "" }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(1, version); }
public static void Build(ILogger log, Package package, string outputDirectory = null) { if (package == null) { throw new ArgumentNullException(nameof(package)); } var meta = new ManifestMetadata(); PackageStore.ToNugetManifest(package.Meta, meta); // Sanity check: Xenko version should be same between NuGet package and Xenko package var nugetVersion = new PackageVersion(XenkoVersion.NuGetVersion).Version; var packageVersion = package.Meta.Version.Version; if (nugetVersion != packageVersion) { log.Error($"Package has mismatching version: NuGet package version is {nugetVersion} and Xenko Package version is {packageVersion}"); return; } if (nugetVersion.Revision <= 0) { // If 0, we have special cases with NuGet dropping it in install path, could be dangerous and lead to bugs if not properly tested. log.Error($"Package has revision {nugetVersion} but 4th digit needs to be at least 1."); return; } // Override version with NuGet version (4th number is different in Xenko package) meta.Version = XenkoVersion.NuGetVersion; var builder = new NugetPackageBuilder(); builder.Populate(meta); var currentAssemblyLocation = Assembly.GetExecutingAssembly().Location; var mainPlatformDirectory = Path.GetFileName(Path.GetDirectoryName(currentAssemblyLocation)); // TODO this is not working // We are excluding everything that is in a folder that starts with a dot (ie. .shadow, .vs) var files = new List <ManifestFile>() { NewFile(@"Bin\**\*.exe", "Bin", @"Bin\**\.*\**\*.exe;Bin\**\Tools\**.exe"), NewFile(@"Bin\**\*.so", "Bin", @"Bin\**\.*\**\*.so;Bin\Windows\lib\**\*.so"), NewFile(@"Bin\**\*.ssdeps", "Bin", @"Bin\**\.*\**\*.ssdeps"), NewFile(@"Bin\**\*.a", "Bin", @"Bin\**\.*\**\*.a"), NewFile(@"Bin\**\*.md", "Bin", @"Bin\**\.*\**\*.md"), NewFile(@"Bin\**\*.html", "Bin", @"Bin\**\.*\**\*.html"), NewFile(@"Bin\**\*.config", "Bin", @"Bin\**\.*\**\*.config"), NewFile(@"Bin\**\*.dll", "Bin", @"Bin\**\.*\**\*.dll;Bin\Windows\lib\**\*.dll"), NewFile(@"Bin\**\*.xml", "Bin", @"Bin\**\.*\**\*.xml"), NewFile(@"Bin\**\*.usrdoc", "Bin", @"Bin\**\.*\**\*.usrdoc"), NewFile(@"Bin\**\*.winmd", "Bin", @"Bin\**\.*\**\*.winmd"), NewFile(@"Bin\**\*.sh", "Bin", @"Bin\**\.*\**\*.sh"), NewFile(@"Bin\**\*.json", "Bin", @"Bin\**\.*\**\*.json"), NewFile(@"deps\AssemblyProcessor\*.exe", @"deps/AssemblyProcessor"), NewFile(@"deps\AssemblyProcessor\*.dll", @"deps/AssemblyProcessor"), NewFile($@"Bin\{mainPlatformDirectory}\ios-tcprelay\*.py", $@"Bin\{mainPlatformDirectory}\ios-tcprelay"), NewFile(@"Targets\*.targets", "Targets"), NewFile(@"Targets\*.props", "Targets"), NewFile($@"Bin\{mainPlatformDirectory}\Xenko.Core.*.pdb", $@"Bin\{mainPlatformDirectory}", @"Bin\**\Xenko.Importer*.pdb;Bin\**\Xenko.Assimp.Translation.pdb"), NewFile(@"build\Xenko.targets", @"build"), NewFile(@"build\Xenko.props", @"build"), NewFile(@"tools\**\*.exe", "tools"), NewFile(@"tools\**\*.dll", "tools"), NewFile(@"LICENSE.md", @""), NewFile(@"THIRD PARTY.md", @""), }; // Handle Assets var rootDir = package.RootDirectory; var newPackage = new Package { Meta = AssetCloner.Clone(package.Meta) }; newPackage.Meta.Version = new PackageVersion(meta.Version); foreach (var profile in package.Profiles) { var target = "Assets/" + profile.Name; foreach (var assetFolder in profile.AssetFolders) { files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xk*", target)); } foreach (var resourceFolder in profile.ResourceFolders) { files.Add(NewFile(resourceFolder.MakeRelative(rootDir) + "/**/*.*", "Resources")); } var targetProfile = new PackageProfile(profile.Name); if (profile.AssetFolders.Count > 0) { targetProfile.AssetFolders.Add(new AssetFolder(target)); } if (profile.ResourceFolders.Count > 0) { targetProfile.ResourceFolders.Add("Resources"); } newPackage.Profiles.Add(targetProfile); } //Handle RootAssets foreach (var rootAsset in package.RootAssets) { newPackage.RootAssets.Add(rootAsset); } // Handle templates var targetFolder = new TemplateFolder("Templates"); foreach (var templateFolder in package.TemplateFolders) { var source = templateFolder.Path.MakeRelative(rootDir) + "/**"; UDirectory target = targetFolder.Path; if (templateFolder.Group != null) { target = UPath.Combine(target, templateFolder.Group); } var excludeFiles = templateFolder.Exclude; files.Add(NewFile(source, target, excludeFiles)); // Add template files foreach (var templateFile in templateFolder.Files) { var newTemplateFile = templateFile.MakeRelative(templateFolder.Path); if (templateFolder.Group != null) { newTemplateFile = UPath.Combine(templateFolder.Group, newTemplateFile); } newTemplateFile = UPath.Combine(targetFolder.Path, newTemplateFile); targetFolder.Files.Add(newTemplateFile); } } // Create temp package for archive newPackage.TemplateFolders.Add(targetFolder); var newPackageFileName = "temp" + Guid.NewGuid() + ".xkpkg"; newPackage.FullPath = package.RootDirectory + "/" + newPackageFileName; var result = new LoggerResult(); newPackage.Save(result); if (result.HasErrors) { throw new InvalidOperationException(result.ToText()); // TODO throw error } files.Add(NewFile(newPackageFileName, package.Meta.Name + Package.PackageFileExtension)); // Add files builder.PopulateFiles(package.RootDirectory, files); outputDirectory = outputDirectory ?? Environment.CurrentDirectory; // Save the nupkg var outputPath = GetOutputPath(builder, outputDirectory); bool isExistingPackage = File.Exists(outputPath); if (isExistingPackage) { File.Delete(outputPath); } try { using (Stream stream = File.Create(outputPath)) { builder.Save(stream); } } catch { if (!isExistingPackage && File.Exists(outputPath)) { File.Delete(outputPath); } throw; } File.Delete(newPackage.FullPath); }
public static XElement ToXElement(this ManifestMetadata metadata, XNamespace ns) { var elem = new XElement(ns + "metadata"); if (metadata.MinClientVersionString != null) { elem.SetAttributeValue("minClientVersion", metadata.MinClientVersionString); } elem.Add(new XElement(ns + "id", metadata.Id)); AddElementIfNotNull(elem, ns, "version", metadata.Version?.ToFullString()); AddElementIfNotNull(elem, ns, "title", metadata.Title); if (!metadata.PackageTypes.Contains(PackageType.SymbolsPackage)) { AddElementIfNotNull(elem, ns, "authors", metadata.Authors, authors => string.Join(",", authors)); AddElementIfNotNull(elem, ns, "owners", metadata.Owners, owners => string.Join(",", owners)); } elem.Add(new XElement(ns + "requireLicenseAcceptance", metadata.RequireLicenseAcceptance)); if (metadata.DevelopmentDependency) { elem.Add(new XElement(ns + "developmentDependency", metadata.DevelopmentDependency)); } AddElementIfNotNull(elem, ns, "licenseUrl", metadata.LicenseUrl); AddElementIfNotNull(elem, ns, "projectUrl", metadata.ProjectUrl); AddElementIfNotNull(elem, ns, "iconUrl", metadata.IconUrl); AddElementIfNotNull(elem, ns, "description", metadata.Description); AddElementIfNotNull(elem, ns, "summary", metadata.Summary); AddElementIfNotNull(elem, ns, "releaseNotes", metadata.ReleaseNotes); AddElementIfNotNull(elem, ns, "copyright", metadata.Copyright); AddElementIfNotNull(elem, ns, "language", metadata.Language); AddElementIfNotNull(elem, ns, "tags", metadata.Tags); if (metadata.Serviceable) { elem.Add(new XElement(ns + "serviceable", metadata.Serviceable)); } if (metadata.PackageTypes != null && metadata.PackageTypes.Any()) { elem.Add(GetXElementFromManifestPackageTypes(ns, metadata.PackageTypes)); } if (metadata.Repository != null) { XElement repoElement = GetXElementFromManifestRepository(ns, metadata.Repository); if (repoElement != null) { elem.Add(repoElement); } } elem.Add(GetXElementFromGroupableItemSets( ns, metadata.DependencyGroups, set => set.TargetFramework.IsSpecificFramework || set.Packages.Any(dependency => dependency.Exclude.Count > 0 || dependency.Include.Count > 0), set => set.TargetFramework.IsSpecificFramework ? set.TargetFramework.GetFrameworkString() : null, set => set.Packages, GetXElementFromPackageDependency, Dependencies, TargetFramework)); elem.Add(GetXElementFromGroupableItemSets( ns, metadata.PackageAssemblyReferences, set => set.TargetFramework?.IsSpecificFramework == true, set => set.TargetFramework?.GetFrameworkString(), set => set.References, GetXElementFromPackageReference, References, TargetFramework)); elem.Add(GetXElementFromFrameworkAssemblies(ns, metadata.FrameworkReferences)); elem.Add(GetXElementFromManifestContentFiles(ns, metadata.ContentFiles)); return(elem); }
/// <summary> /// Gets the <see cref="ManifestMetadata" /> for a package. /// </summary> /// <summary> /// Initializes a new instance of the <see cref="PackageManifest"/> class. /// </summary> /// <param name="name">The name or ID of the package.</param> /// <param name="version">The semantic version of the package.</param> /// <param name="authors">An optional semicolon delimited list of authors of the package. The default value is "UserA"</param> /// <param name="description">An optional description of the package. The default value is "Description"</param> /// <param name="copyright">An optional copyright of the package.</param> /// <param name="developmentDependency">An optional value indicating whether or not the package is a development dependency. The default value is <code>false</code>.</param> /// <param name="iconUrl">An optional URL to the icon of the package.</param> /// <param name="language">An optional language of the package.</param> /// <param name="licenseUrl">An optional URL to the license of the package.</param> /// <param name="licenseMetadata">An optional <see cref="LicenseMetadata" /> of the package.</param> /// <param name="owners">An optional semicolon delimited list of owners of the package.</param> /// <param name="packageTypes">An optional <see cref="IEnumerable{PackageType}" /> containing the package types of the package.</param> /// <param name="projectUrl">An optional URL to the project of the package.</param> /// <param name="releaseNotes">An optional value specifying release notes of the package.</param> /// <param name="repositoryType">An optional value specifying the type of source code repository of the package.</param> /// <param name="repositoryUrl">An optional value specifying the URL of the source code repository of the package.</param> /// <param name="repositoryBranch">An optional value specifying the branch of the source code repository of the package.</param> /// <param name="repositoryCommit">An optional value specifying the commit of the source code repository of the package.</param> /// <param name="requireLicenseAcceptance">An optional value indicating whether or not the package requires license acceptance The default value is <code>false</code>.</param> /// <param name="serviceable">An option value indicating whether or not the package is serviceable. The default value is <code>false</code>.</param> /// <param name="summary">An optional summary of the package.</param> /// <param name="tags">An optional set of tags of the package.</param> /// <param name="title">An optional title of the package.</param> /// <returns>The <see cref="ManifestMetadata" /> for the package.</returns> #else /// <summary> /// Gets the <see cref="ManifestMetadata" /> for a package. /// </summary> /// <summary> /// Initializes a new instance of the <see cref="PackageManifest"/> class. /// </summary> /// <param name="name">The name or ID of the package.</param> /// <param name="version">The semantic version of the package.</param> /// <param name="authors">An optional semicolon delimited list of authors of the package. The default value is "UserA"</param> /// <param name="description">An optional description of the package. The default value is "Description"</param> /// <param name="copyright">An optional copyright of the package.</param> /// <param name="developmentDependency">An optional value indicating whether or not the package is a development dependency. The default value is <code>false</code>.</param> /// <param name="icon">An optional path in the package that should be used for the icon of the package.</param> /// <param name="iconUrl">An optional URL to the icon of the package.</param> /// <param name="language">An optional language of the package.</param> /// <param name="licenseUrl">An optional URL to the license of the package.</param> /// <param name="licenseMetadata">An optional <see cref="LicenseMetadata" /> of the package.</param> /// <param name="owners">An optional semicolon delimited list of owners of the package.</param> /// <param name="packageTypes">An optional <see cref="IEnumerable{PackageType}" /> containing the package types of the package.</param> /// <param name="projectUrl">An optional URL to the project of the package.</param> /// <param name="releaseNotes">An optional value specifying release notes of the package.</param> /// <param name="repositoryType">An optional value specifying the type of source code repository of the package.</param> /// <param name="repositoryUrl">An optional value specifying the URL of the source code repository of the package.</param> /// <param name="repositoryBranch">An optional value specifying the branch of the source code repository of the package.</param> /// <param name="repositoryCommit">An optional value specifying the commit of the source code repository of the package.</param> /// <param name="requireLicenseAcceptance">An optional value indicating whether or not the package requires license acceptance The default value is <code>false</code>.</param> /// <param name="serviceable">An option value indicating whether or not the package is serviceable. The default value is <code>false</code>.</param> /// <param name="summary">An optional summary of the package.</param> /// <param name="tags">An optional set of tags of the package.</param> /// <param name="title">An optional title of the package.</param> /// <returns>The <see cref="ManifestMetadata" /> for the package.</returns> #endif private static ManifestMetadata GetManifestMetadata( string name, string version, string authors = null, string description = null, string copyright = null, bool developmentDependency = false, #if !NET46 string icon = null, #endif string iconUrl = null, string language = null, string licenseUrl = null, LicenseMetadata licenseMetadata = null, string owners = null, IEnumerable <PackageType> packageTypes = null, string projectUrl = null, string releaseNotes = null, string repositoryType = null, string repositoryUrl = null, string repositoryBranch = null, string repositoryCommit = null, bool requireLicenseAcceptance = false, bool serviceable = false, string summary = null, string tags = null, string title = null) { ManifestMetadata metadata = new ManifestMetadata { Authors = MSBuildStringUtility.Split(authors ?? "UserA"), Copyright = copyright, Description = description ?? "Description", DevelopmentDependency = developmentDependency, #if !NET46 Icon = icon, #endif Id = name, Language = language, LicenseMetadata = licenseMetadata, Owners = string.IsNullOrWhiteSpace(owners) ? null : MSBuildStringUtility.Split(owners), PackageTypes = packageTypes ?? new[] { PackageType.Dependency }, ReleaseNotes = releaseNotes, Repository = new RepositoryMetadata(repositoryType, repositoryUrl, repositoryBranch, repositoryCommit), RequireLicenseAcceptance = requireLicenseAcceptance, Serviceable = serviceable, Summary = summary, Tags = tags, Title = title, Version = NuGetVersion.Parse(version), }; if (!string.IsNullOrWhiteSpace(iconUrl)) { metadata.SetIconUrl(iconUrl); } if (!string.IsNullOrWhiteSpace(licenseUrl)) { metadata.SetLicenseUrl(licenseUrl); } if (!string.IsNullOrWhiteSpace(projectUrl)) { metadata.SetProjectUrl(projectUrl); } return(metadata); }
private static List <PackageDependencySet> GetOtherDependencySets(ManifestMetadata manifestMetadata) { var dependencySets = manifestMetadata.DependencyGroups.Where(x => !x.TargetFramework.IsAgnostic); return(s_mapper.Map <List <PackageDependencySet> >(dependencySets)); }
public void OWnersIsEmptyByDefault() { var metadata = new ManifestMetadata(); Assert.Empty(metadata.Owners); }
public void AuthorsIsEmptyByDefault() { var metadata = new ManifestMetadata(); Assert.Empty(metadata.Authors); }
public static void Build(ILogger log, Package package, string outputDirectory = null) { if (package == null) { throw new ArgumentNullException(nameof(package)); } var meta = new ManifestMetadata(); PackageStore.ToNugetManifest(package.Meta, meta); // Sanity check: Xenko version should be same between NuGet package and Xenko package var nugetVersion = new PackageVersion(XenkoVersion.NuGetVersion).Version; var packageVersion = package.Meta.Version.Version; if (nugetVersion != packageVersion) { log.Error($"Package has mismatching version: NuGet package version is {nugetVersion} and Xenko Package version is {packageVersion}"); return; } if (nugetVersion.Revision <= 0) { // If 0, we have special cases with NuGet dropping it in install path, could be dangerous and lead to bugs if not properly tested. log.Error($"Package has revision {nugetVersion} but 4th digit needs to be at least 1."); return; } // Override version with NuGet version (4th number is different in Xenko package) meta.Version = XenkoVersion.NuGetVersion; var builder = new NugetPackageBuilder(); builder.Populate(meta); var currentAssemblyLocation = Assembly.GetExecutingAssembly().Location; var mainPlatformDirectory = Path.GetFileName(Path.GetDirectoryName(currentAssemblyLocation)); // TODO this is not working // We are excluding everything that is in a folder that starts with a dot (ie. .shadow, .vs) var files = new List <ManifestFile>() { NewFile(@"Bin\**\*.exe", "Bin", @"Bin\**\.*\**\*.exe;Bin\**\Tools\**.exe"), NewFile(@"Bin\**\*.so", "Bin", @"Bin\**\.*\**\*.so;Bin\Windows\lib\**\*.so"), NewFile(@"Bin\**\*.ssdeps", "Bin", @"Bin\**\.*\**\*.ssdeps"), NewFile(@"Bin\**\*.a", "Bin", @"Bin\**\.*\**\*.a"), NewFile(@"Bin\**\*.md", "Bin", @"Bin\**\.*\**\*.md"), NewFile(@"Bin\**\*.html", "Bin", @"Bin\**\.*\**\*.html"), NewFile(@"Bin\**\*.config", "Bin", @"Bin\**\.*\**\*.config"), NewFile(@"Bin\**\*.dll", "Bin", @"Bin\**\.*\**\*.dll;Bin\Windows\lib\**\*.dll"), NewFile(@"Bin\**\*.xml", "Bin", @"Bin\**\.*\**\*.xml"), NewFile(@"Bin\**\*.usrdoc", "Bin", @"Bin\**\.*\**\*.usrdoc"), NewFile(@"Bin\**\*.winmd", "Bin", @"Bin\**\.*\**\*.winmd"), NewFile(@"Bin\**\*.sh", "Bin", @"Bin\**\.*\**\*.sh"), NewFile(@"Bin\**\*.json", "Bin", @"Bin\**\.*\**\*.json"), NewFile(@"deps\AssemblyProcessor\*.exe", @"deps/AssemblyProcessor"), NewFile(@"deps\AssemblyProcessor\*.dll", @"deps/AssemblyProcessor"), NewFile(@"deps\CoreFX\**\*.*", @"deps\CoreFX"), NewFile($@"Bin\{mainPlatformDirectory}\ios-tcprelay\*.py", $@"Bin\{mainPlatformDirectory}\ios-tcprelay"), NewFile(@"Targets\*.targets", "Targets"), NewFile($@"Bin\{mainPlatformDirectory}\SiliconStudio.*.pdb", $@"Bin\{mainPlatformDirectory}", @"Bin\**\SiliconStudio.Xenko.Importer*.pdb;Bin\**\SiliconStudio.Xenko.Assimp.Translation.pdb"), }; // Handle Assets var rootDir = package.RootDirectory; var newPackage = new Package { Meta = package.Meta }; foreach (var profile in package.Profiles) { var target = "Assets/" + profile.Name; foreach (var assetFolder in profile.AssetFolders) { // TODO: handle exclude in asset folders //files.Add(NewFile(source, target, @"**\*.cs;**\*.hlsl;**\*.csproj;**\*.csproj.user;**\obj\**")); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xksl", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkfx", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkfnt", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xksheet", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkuilib", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkgfxcomp", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xktex", target)); var resourceFolder = UPath.Combine(assetFolder.Path, new UDirectory("../../Resources")); if (Directory.Exists(resourceFolder.ToWindowsPath())) { files.Add(NewFile(resourceFolder.MakeRelative(rootDir) + "/**/*.*", "Resources")); } } var targetProfile = new PackageProfile(profile.Name); targetProfile.AssetFolders.Add(new AssetFolder(target)); newPackage.Profiles.Add(targetProfile); } //Handle RootAssets foreach (var rootAsset in package.RootAssets) { newPackage.RootAssets.Add(rootAsset); } // Handle templates var targetFolder = new TemplateFolder("Templates"); foreach (var templateFolder in package.TemplateFolders) { var source = templateFolder.Path.MakeRelative(rootDir) + "/**"; UDirectory target = targetFolder.Path; if (templateFolder.Group != null) { target = UPath.Combine(target, templateFolder.Group); } var excludeFiles = templateFolder.Exclude; files.Add(NewFile(source, target, excludeFiles)); // Add template files foreach (var templateFile in templateFolder.Files) { var newTemplateFile = templateFile.MakeRelative(templateFolder.Path); if (templateFolder.Group != null) { newTemplateFile = UPath.Combine(templateFolder.Group, newTemplateFile); } newTemplateFile = UPath.Combine(targetFolder.Path, newTemplateFile); targetFolder.Files.Add(newTemplateFile); } } // Add files builder.PopulateFiles(package.RootDirectory, files); files.Clear(); var dataFiles = builder.Files.ToList(); builder.ClearFiles(); // Create temp package for archive newPackage.TemplateFolders.Add(targetFolder); var newPackageFileName = "temp" + Guid.NewGuid() + ".xkpkg"; newPackage.FullPath = package.RootDirectory + "/" + newPackageFileName; var result = new LoggerResult(); newPackage.Save(result); if (result.HasErrors) { throw new InvalidOperationException(result.ToText()); // TODO throw error } // Add the package file files.Add(NewFile(newPackageFileName, package.Meta.Name + Package.PackageFileExtension)); // Add entry point to decompress LZMA files.Add(NewFile(@"tools\**\*.exe", "tools")); files.Add(NewFile(@"tools\**\*.dll", "tools")); // Add an empty .xz file so that it gets added to [Content_Types].xml // This file will be removed later files.Add(NewFile(@"tools\data_empty.xz", string.Empty)); // Repopulate with .xkpkg file builder.PopulateFiles(package.RootDirectory, files); outputDirectory = outputDirectory ?? Environment.CurrentDirectory; // Save the nupkg var outputPath = GetOutputPath(builder, outputDirectory); bool isExistingPackage = File.Exists(outputPath); if (isExistingPackage) { File.Delete(outputPath); } try { using (Stream stream = File.Create(outputPath)) { builder.Save(stream); stream.Position = 0; // Add LZMA file as update so that it is stored without compression using (var archive = new ZipArchive(stream, ZipArchiveMode.Update, true)) { // Delete data_empty.xz var dataEntry = archive.GetEntry("data_empty.xz"); dataEntry.Delete(); // Create data.xz (no compression since .xz is already compressed) dataEntry = archive.CreateEntry("data.xz", CompressionLevel.NoCompression); using (var dataStream = dataEntry.Open()) { // Generate LZMA using (var indexedArchive = new IndexedArchive()) { foreach (var file in dataFiles) { indexedArchive.AddFile(Path.Combine(package.RootDirectory, file.SourcePath), file.Path); } indexedArchive.Save(dataStream, new ConsoleProgressReport()); } } } } } catch { if (!isExistingPackage && File.Exists(outputPath)) { File.Delete(outputPath); } throw; } File.Delete(newPackage.FullPath); }
public Manifest() { Metadata = new ManifestMetadata(); }
private static void ReadMetadataValue(ManifestMetadata manifestMetadata, XElement element, HashSet<string> allElements) { if (element.Value != null) { allElements.Add(element.Name.LocalName); string s = element.Value.SafeTrim(); switch (element.Name.LocalName) { case "id": manifestMetadata.Id = s; return; case "version": manifestMetadata.Version = s; return; case "authors": manifestMetadata.Authors = s; return; case "owners": manifestMetadata.Owners = s; return; case "licenseUrl": manifestMetadata.LicenseUrl = s; return; case "projectUrl": manifestMetadata.ProjectUrl = s; return; case "iconUrl": manifestMetadata.IconUrl = s; return; case "requireLicenseAcceptance": manifestMetadata.RequireLicenseAcceptance = XmlConvert.ToBoolean(s); return; case "developmentDependency": manifestMetadata.DevelopmentDependency = XmlConvert.ToBoolean(s); return; case "description": manifestMetadata.Description = s; return; case "summary": manifestMetadata.Summary = s; return; case "releaseNotes": manifestMetadata.ReleaseNotes = s; return; case "copyright": manifestMetadata.Copyright = s; return; case "language": manifestMetadata.Language = s; return; case "title": manifestMetadata.Title = s; return; case "tags": manifestMetadata.Tags = s; return; case "dependencies": //manifestMetadata.DependencySets = ReadDependencySets(element); return; case "frameworkAssemblies": //manifestMetadata.FrameworkAssemblies = ReadFrameworkAssemblies(element); return; case "references": //manifestMetadata.ReferenceSets = ReadReferenceSets(element); return; } } }
public Task Execute(string[] commandLineArguments) { return Task.Run(() => { optionGroups.Parse(commandLineArguments); if (string.IsNullOrWhiteSpace(id)) throw new CommandException("An ID is required"); if (includes.All(string.IsNullOrWhiteSpace)) includes.Add("**"); if (string.IsNullOrWhiteSpace(basePath)) basePath = Path.GetFullPath(Directory.GetCurrentDirectory()); if (string.IsNullOrWhiteSpace(outFolder)) outFolder = Path.GetFullPath(Directory.GetCurrentDirectory()); if (version == null) { var now = DateTime.Now; version = SemanticVersion.Parse($"{now.Year}.{now.Month}.{now.Day}.{now.Hour*10000 + now.Minute*100 + now.Second}"); } if (authors.All(string.IsNullOrWhiteSpace)) authors.Add(Environment.GetEnvironmentVariable("USERNAME") + "@" + Environment.GetEnvironmentVariable("USERDOMAIN")); if (string.IsNullOrWhiteSpace(description)) description = "A deployment package created from files on disk."; string allReleaseNotes = null; if (!string.IsNullOrWhiteSpace(releaseNotesFile)) { if (!File.Exists(releaseNotesFile)) log.Warning("The release notes file '{Path:l}' could not be found", releaseNotesFile); else allReleaseNotes = fileSystem.ReadFile(releaseNotesFile); } if (!string.IsNullOrWhiteSpace(releaseNotes)) { if (allReleaseNotes != null) allReleaseNotes += Environment.NewLine + releaseNotes; else allReleaseNotes = releaseNotes; } if (string.IsNullOrWhiteSpace(version.OriginalString)) { throw new Exception("Somehow we created a SemanticVersion without the OriginalString value being preserved. We want to use the OriginalString so we can preserve the version as intended by the caller."); } var metadata = new ManifestMetadata { Id = id, Authors = authors, Description = description, Version = NuGetVersion.Parse(version.OriginalString) }; if (!string.IsNullOrWhiteSpace(allReleaseNotes)) metadata.ReleaseNotes = allReleaseNotes; if (!string.IsNullOrWhiteSpace(title)) metadata.Title = title; log.Information("Packing {PackageId:l} version {Version}...", id, version); packageBuilder.BuildPackage(basePath, includes, metadata, outFolder, overwrite); log.Information("Done."); }); }
public void GetManifestVersionConsidersEmptyLists() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description", FrameworkAssemblies = new List<ManifestFrameworkAssembly> { }, References = new List<ManifestReference> { } }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(2, version); }
public void GetManifestVersionReturns2IfReleaseNotesIsPresent() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0", Authors = "A, B", Description = "Description", ReleaseNotes = "Notes.txt" }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(2, version); }
public void Execute(string[] commandLineArguments) { options.Parse(commandLineArguments); if (string.IsNullOrWhiteSpace(id)) { throw new CommandException("An ID is required"); } if (includes.All(string.IsNullOrWhiteSpace)) { includes.Add("**"); } if (string.IsNullOrWhiteSpace(basePath)) { basePath = Path.GetFullPath(Environment.CurrentDirectory); } if (string.IsNullOrWhiteSpace(outFolder)) { outFolder = Path.GetFullPath(Environment.CurrentDirectory); } if (version == null) { var now = DateTime.Now; version = new SemanticVersion(now.Year, now.Month, now.Day, now.Hour * 10000 + now.Minute * 100 + now.Second); } else { // Make sure SpecialVersion has 20 characters maximum (Limit imposed by NuGet) // https://nuget.codeplex.com/workitem/3426 const int nugetSpecialVersionMaxLength = 20; if (!string.IsNullOrWhiteSpace(version.SpecialVersion) && version.SpecialVersion.Length > nugetSpecialVersionMaxLength) { log.WarnFormat("SpecialVersion '{0}' will be truncated to {1} characters (NuGet limit)", version.SpecialVersion, nugetSpecialVersionMaxLength); var specialVersion = version.SpecialVersion; specialVersion = specialVersion.Substring(0, Math.Min(nugetSpecialVersionMaxLength, specialVersion.Length)); version = new SemanticVersion(version.Version, specialVersion); } } if (authors.All(string.IsNullOrWhiteSpace)) { authors.Add(Environment.UserName + "@" + Environment.UserDomainName); } if (string.IsNullOrWhiteSpace(description)) { description = "A deployment package created from files on disk."; } string allReleaseNotes = null; if (!string.IsNullOrWhiteSpace(releaseNotesFile)) { if (!File.Exists(releaseNotesFile)) { log.WarnFormat("The release notes file '{0}' could not be found", releaseNotesFile); } else { allReleaseNotes = fileSystem.ReadFile(releaseNotesFile); } } if (!string.IsNullOrWhiteSpace(releaseNotes)) { if (allReleaseNotes != null) { allReleaseNotes += Environment.NewLine + releaseNotes; } else { allReleaseNotes = releaseNotes; } } var metadata = new ManifestMetadata { Id = id, Authors = string.Join(", ", authors), Description = description, Version = version.ToString(), }; if (!string.IsNullOrWhiteSpace(allReleaseNotes)) { metadata.ReleaseNotes = allReleaseNotes; } if (!string.IsNullOrWhiteSpace(title)) { metadata.Title = title; } log.InfoFormat("Packing {0} version {1}...", id, version); var package = new PackageBuilder(); package.PopulateFiles(basePath, includes.Select(i => new ManifestFile { Source = i })); package.Populate(metadata); var filename = metadata.Id + "." + metadata.Version + ".nupkg"; var output = Path.Combine(outFolder, filename); if (fileSystem.FileExists(output) && !overwrite) { throw new CommandException("The package file already exists and --overwrite was not specified"); } log.InfoFormat("Saving {0} to {1}...", filename, outFolder); fileSystem.EnsureDirectoryExists(outFolder); using (var outStream = fileSystem.OpenFile(output, FileMode.Create)) package.Save(outStream); log.InfoFormat("Done."); }
public void GetManifestVersionReturns3IfUsingSemanticVersioning() { // Arrange var metadata = new ManifestMetadata { Id = "Foo", Version = "1.0.0-alpha", Authors = "A, B", Description = "Description" }; // Act var version = ManifestVersionUtility.GetManifestVersion(metadata); // Assert Assert.Equal(3, version); }
public Task Execute(string[] commandLineArguments) { return(Task.Run(() => { Options.Parse(commandLineArguments); if (printHelp) { this.GetHelp(Console.Out, commandLineArguments); return; } commandOutputProvider.PrintMessages = this.OutputFormat == OutputFormat.Default || this.verbose; if (string.IsNullOrWhiteSpace(id)) { throw new CommandException("An ID is required"); } if (includes.All(string.IsNullOrWhiteSpace)) { includes.Add("**"); } if (string.IsNullOrWhiteSpace(basePath)) { basePath = Path.GetFullPath(Directory.GetCurrentDirectory()); } if (string.IsNullOrWhiteSpace(outFolder)) { outFolder = Path.GetFullPath(Directory.GetCurrentDirectory()); } if (version == null) { var now = DateTime.Now; version = SemanticVersion.Parse($"{now.Year}.{now.Month}.{now.Day}.{now.Hour*10000 + now.Minute*100 + now.Second}"); } if (authors.All(string.IsNullOrWhiteSpace)) { authors.Add(System.Environment.GetEnvironmentVariable("USERNAME") + "@" + System.Environment.GetEnvironmentVariable("USERDOMAIN")); } if (string.IsNullOrWhiteSpace(description)) { description = "A deployment package created from files on disk."; } allReleaseNotes = null; if (!string.IsNullOrWhiteSpace(releaseNotesFile)) { if (!File.Exists(releaseNotesFile)) { commandOutputProvider.Warning("The release notes file '{Path:l}' could not be found", releaseNotesFile); } else { allReleaseNotes = fileSystem.ReadFile(releaseNotesFile); } } if (!string.IsNullOrWhiteSpace(releaseNotes)) { if (allReleaseNotes != null) { allReleaseNotes += System.Environment.NewLine + releaseNotes; } else { allReleaseNotes = releaseNotes; } } if (string.IsNullOrWhiteSpace(version.OriginalString)) { throw new Exception("Somehow we created a SemanticVersion without the OriginalString value being preserved. We want to use the OriginalString so we can preserve the version as intended by the caller."); } var metadata = new ManifestMetadata { Id = id, Authors = authors, Description = description, Version = NuGetVersion.Parse(version.OriginalString) }; if (!string.IsNullOrWhiteSpace(allReleaseNotes)) { metadata.ReleaseNotes = allReleaseNotes; } if (!string.IsNullOrWhiteSpace(title)) { metadata.Title = title; } packageBuilder.SetCompression(compressionLevel); if (verbose) { commandOutputProvider.Information("Verbose logging"); } commandOutputProvider.Information("Packing {id:l} version {Version}...", id, version); packageBuilder.BuildPackage(basePath, includes, metadata, outFolder, overwrite, verbose); if (OutputFormat == OutputFormat.Json) { PrintJsonOutput(); } else { PrintDefaultOutput(); } })); }
public IPackage CreatePackage( string packageId, string packageVersion, string contentFilePath, License requiresLicenseAccept, params IPackage[] dependencies) { PackageBuilder builder = new PackageBuilder(); ManifestMetadata metadata = new ManifestMetadata() { Authors = "dummy author", Version = new SemanticVersion(packageVersion).ToString(), Id = packageId, Description = "dummy description", LicenseUrl = "http://choosealicense.com/", RequireLicenseAcceptance = (requiresLicenseAccept == License.Required) }; List <ManifestDependency> dependencyList = new List <ManifestDependency>(); foreach (IPackage dependencyNode in dependencies) { dependencyList.Add(new ManifestDependency() { Id = dependencyNode.Id, Version = dependencyNode.Version.ToString(), }); } List <ManifestDependencySet> dependencySetList = new List <ManifestDependencySet>() { new ManifestDependencySet() { Dependencies = dependencyList } }; metadata.DependencySets = dependencySetList; builder.Populate(metadata); PhysicalPackageFile file = new PhysicalPackageFile { SourcePath = contentFilePath, TargetPath = Path.GetFileName(contentFilePath) }; builder.Files.Add(file); string fileName = packageId + "." + metadata.Version + ".nupkg"; string destinationName = Path.Combine(manager.LocalRepository.Source, fileName); using (Stream fileStream = File.Open(destinationName, FileMode.OpenOrCreate)) { builder.Save(fileStream); } // Retrieve and return the newly-created package IPackage package = FakeRemoteRepo.FindPackage(packageId, new SemanticVersion(packageVersion)); package.Should().NotBeNull("Test setup error: failed to create and retrieve a test package"); return(package); }
internal static async Task <OperationResult> GenerateNugetPackage( string resultFile, string packageId, string version, string authors, string owners, string description, string outputFolder) { Directory.CreateDirectory(outputFolder); var tempDirectoryPath = Path.GetTempPath(); Directory.CreateDirectory(tempDirectoryPath); var resultFileName = Path.GetFileName(resultFile); string targetsFile = Path.Combine(tempDirectoryPath, $"{packageId}.targets"); var targetsContents = $@"<?xml version=""1.0"" encoding=""utf-8"" ?> <Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003""> <ItemGroup> <LarnacaFiles Include=""$(MSBuildThisFileDirectory)..\contentFiles\**\{resultFileName}""> <Version>{version}</Version> <PackageIdentity>{packageId}</PackageIdentity> </LarnacaFiles> </ItemGroup> </Project> "; File.WriteAllText(targetsFile, targetsContents); ManifestMetadata metadata = new ManifestMetadata() { Authors = new string[] { authors }, Owners = new string[] { owners }, Version = new NuGetVersion(version), Id = packageId, Description = description, ContentFiles = new List <ManifestContentFiles>() { new ManifestContentFiles() { Include = "**/obj/*.*", BuildAction = "none" } }, DependencyGroups = new PackageDependencyGroup[] { new PackageDependencyGroup(NuGet.Frameworks.NuGetFramework.AnyFramework, new PackageDependency[] { new PackageDependency("protobuf-net", new VersionRange(new NuGetVersion("2.4.2"))) }) } }; PackageBuilder builder = new PackageBuilder(); builder.PopulateFiles("", new ManifestFile[] { new ManifestFile() { Source = resultFile, Target = Path.Combine("contentFiles", "any", "any", "obj", resultFileName) }, new ManifestFile() { Source = targetsFile, Target = Path.Combine("build", $"{packageId}.targets") } }); builder.Populate(metadata); var nugetFileName = $"{packageId}.{version}.nupkg"; string nugetPackageFile = Path.Combine(tempDirectoryPath, nugetFileName); // not deleting the file and overwriting it results in a corrupted archive if (File.Exists(nugetPackageFile)) { File.Delete(nugetPackageFile); } using (FileStream stream = File.Open(nugetPackageFile, FileMode.CreateNew)) { builder.Save(stream); stream.Flush(); } File.Delete(targetsFile); File.Move(nugetPackageFile, Path.Combine(outputFolder, nugetFileName)); return(new OperationResult()); }
static private void Create(string solution, string project, string configuration, string plateform, string assembly) { var _assembly = AssemblyDefinition.ReadAssembly(assembly); var _name = _assembly.Name.Name; var _version = _assembly.Metadata <AssemblyFileVersionAttribute>(); var _directory = Path.GetDirectoryName(assembly); var _dependencies = new PackageReferenceFile(string.Concat(Path.GetDirectoryName(project), @"\packages.config")).GetPackageReferences().Where(_Package => _Package.Id != "NuPack").ToArray(); var _extension = _dependencies.Any(_Dependency => _Dependency.Id == "NuPack.Extension"); var _setting = new Setting(solution, project, configuration, plateform, assembly); var _specification = Program.Specification(project); if (_specification == null) { var _builder = typeof(PackageBuilder).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, new Type[] { typeof(bool) }, null).Invoke(new object[] { true }) as PackageBuilder; var _metadata = new ManifestMetadata() { Id = _name, Title = _assembly.Metadata <AssemblyProductAttribute>() ?? _name, Authors = _assembly.Metadata <AssemblyCompanyAttribute>() ?? "-", Version = _version, Summary = _assembly.Metadata <AssemblyDescriptionAttribute>() ?? (_assembly.Metadata <AssemblyProductAttribute>() ?? "-"), Description = _assembly.Metadata <AssemblyDescriptionAttribute>() ?? "-", Copyright = _assembly.Metadata <AssemblyCopyrightAttribute>() ?? "-" }; _builder.Populate(_metadata); if (assembly.EndsWith(".exe", StringComparison.CurrentCultureIgnoreCase)) { if (_extension) { throw new NotSupportedException(); } var _targets = string.Concat(assembly.Substring(0, assembly.Length - 4), ".targets"); _builder.PopulateFiles(null, Program.Bin(_directory).Select(_Filename => new ManifestFile() { Source = _Filename, Target = "build" })); var _plugins = Program.Extends(_dependencies, _setting, ref _builder); Program.Try(() => { if (File.Exists(_targets)) { File.Delete(_targets); } }); using (var _stream = typeof(Program).Assembly.GetManifestResourceStream("NuPack.Template")) { File.WriteAllText(_targets, new StreamReader(_stream).ReadToEnd().Replace("[name]", _name).Replace("[version]", _builder.Version.ToOriginalString()), Encoding.UTF8); } var _filename = Program.Save(_directory, _builder); Program.Try(() => { if (File.Exists(_targets)) { File.Delete(_targets); } }); Console.WriteLine($"{ _name } -> { _filename }"); foreach (var _plugin in _plugins) { _plugin.Dispose(); } } else { if (_extension) { _builder.Files.AddRange(Program.Template().GetContentFiles()); _builder.PopulateFiles(null, Program.Bin(_directory, "Microsoft.Web.XmlTransform.dll", "NuGet.Core.dll", "NuPack.Extension.dll", "NuPack.Extension.xml").Select(_Filename => new ManifestFile() { Source = _Filename, Target = $"NuPack" })); var _plugins = Program.Extends(_dependencies, _setting, ref _builder); Console.WriteLine($"{ _name } -> { Program.Save(_directory, _builder) }"); foreach (var _plugin in _plugins) { _plugin.Dispose(); } } else { var _dictionary = _dependencies.Select(_Dependency => string.Concat(solution, @"packages\", _Dependency.Id, ".", _Dependency.Version, @"\lib")).Where(_Library => Directory.Exists(_Library)).SelectMany(_Library => Directory.EnumerateFiles(_Library, "*", SearchOption.AllDirectories)).ToArray(); foreach (var _dependency in _dependencies.GroupBy(_Package => _Package.TargetFramework)) { _builder.DependencySets.Add(new PackageDependencySet(_dependency.Key, _dependency.Select(_Package => new PackageDependency(_Package.Id, _Package.VersionConstraint, null, null)))); } var _targets = string.Concat(assembly.Substring(0, assembly.Length - 4), ".targets"); if (_dictionary.Any(_Resource => !_Resource.EndsWith(".dll", StringComparison.CurrentCultureIgnoreCase))) { using (var _stream = typeof(Program).Assembly.GetManifestResourceStream("NuPack.Template")) { var _document = XDocument.Parse(new StreamReader(_stream).ReadToEnd().Replace("[name]", _name), LoadOptions.PreserveWhitespace); var _namespace = _document.Root.Name.Namespace; var _sequence = _document.Descendants(_namespace.GetName("Target")).Single(); _sequence.RemoveNodes(); foreach (var _dependency in _dependencies) { var _library = string.Concat(solution, @"packages\", _dependency.Id, ".", _dependency.Version.ToOriginalString(), @"\lib"); if (Directory.Exists(_library)) { foreach (var _resource in Directory.EnumerateFiles(_library).Select(_Filename => Path.GetFileName(_Filename))) { if (_resource.EndsWith(".dll", StringComparison.CurrentCultureIgnoreCase)) { continue; } _sequence.Add(new XElement(_namespace.GetName("Exec"), new XAttribute("Command", $"xcopy /f /q /y \"$(SolutionDir)packages\\{ _dependency.Id }.{ _dependency.Version }\\lib\\{ _resource }\" \"$(ProjectDir)$(OutDir)*\" > nul"))); } } } File.WriteAllText(_targets, _document.ToString(), Encoding.UTF8); _builder.PopulateFiles(null, new ManifestFile[] { new ManifestFile() { Source = _targets, Target = $"build" } }); } } var _framework = $"lib/net{ _assembly.MainModule.RuntimeVersion[1] }{ _assembly.MainModule.RuntimeVersion[3] }/"; var _resources = _dictionary.Select(_Resource => Path.GetFileName(_Resource)).Concat(Program.Resources(project, configuration, false)).Select(_Resource => _Resource.ToLower()).Distinct().ToArray(); _builder.PopulateFiles(null, Program.Bin(_directory, Path.GetFileName(_targets)).Where(_Resource => !_resources.Contains(Path.GetFileName(_Resource).ToLower())).Select(_Resource => new ManifestFile() { Source = _Resource, Target = _framework })); var _plugins = Program.Extends(_dependencies, _setting, ref _builder); var _filename = Program.Save(_directory, _builder); Program.Try(() => { if (File.Exists(_targets)) { File.Delete(_targets); } }); Console.WriteLine($"{ _name } -> { _filename }"); foreach (var _plugin in _plugins) { _plugin.Dispose(); } } } } else { var _builder = new PackageBuilder(); var _manifest = Program.Open(_specification); _builder.Populate(_manifest.Metadata); _builder.PopulateFiles(null, _manifest.Files); var _plugins = Program.Extends(_dependencies, _setting, ref _builder); Console.WriteLine($"{ _name } -> { Program.Save(_directory, _builder) }"); foreach (var _plugin in _plugins) { _plugin.Dispose(); } } }
private static void Main(string[] args) { var options = new Options(); var result = Parser.Default.ParseArguments(args, options); if (!result) { throw new NotSupportedException("Invalid arguments"); } if (!File.Exists(options.PackageToPromote)) { throw new FileNotFoundException("Cannot find the file", options.PackageToPromote); } var package = new ZipPackage(options.PackageToPromote); var temppath = Path.GetTempPath() + Guid.NewGuid(); package.ExtractContents(new PhysicalFileSystem(temppath), ""); Console.WriteLine("Package Id: " + package.Id); Console.WriteLine($"Extracted to {temppath}"); var match = Regex.Match(package.Version.ToString(), @"\d+\.\d+\.\d+"); if (!match.Success) { throw new NotSupportedException("No semantic version was found in the metadata of the package."); } var newVersion = match.Value; Console.WriteLine($"The new version of the package will be {newVersion}"); // Try to find rcedit.exe var exe = findExecutable("rcedit.exe"); foreach (var dimaExe in Directory.GetFiles(temppath, "*.exe")) { Console.WriteLine($"Adjusting the product version of {dimaExe} to {newVersion}"); var rceditargs = $"{dimaExe} --set-product-version {newVersion}"; var process = Process.Start(exe, rceditargs); process.WaitForExit(10000); if (process.ExitCode != 0) { var msg = $"Failed to modify resources, command invoked was: '{exe} {string.Join(" ", rceditargs)}'"; throw new Exception(msg); } } var metadata = new ManifestMetadata { Id = package.Id, Version = newVersion, Title = package.Title, ReleaseNotes = package.ReleaseNotes, Summary = package.Summary, Description = package.Description, Copyright = package.Copyright, Language = package.Language }; if (package.IconUrl != null) { metadata.IconUrl = package.IconUrl.ToString(); } if (package.LicenseUrl != null) { metadata.LicenseUrl = package.LicenseUrl.ToString(); } if (package.ProjectUrl != null) { metadata.ProjectUrl = package.ProjectUrl.ToString(); } if (package.Owners != null) { metadata.Owners = string.Join(", ", package.Owners); } if (package.Authors != null) { metadata.Authors = string.Join(", ", package.Authors); } var builder = new PackageBuilder(); var files = Directory.GetFiles(temppath, "*", SearchOption.AllDirectories) .Where(f => !f.EndsWith(".nuspec")) .Select(f => new ManifestFile { Source = f, Target = f.Replace(temppath, "") }) .ToList(); builder.PopulateFiles("", files); builder.Populate(metadata); if (string.IsNullOrEmpty(options.OutputPath)) { options.OutputPath = Directory.GetCurrentDirectory(); } var outputFile = Path.Combine(options.OutputPath, $"{package.Id}.{newVersion}.nupkg"); Console.WriteLine($"Saving new file to {outputFile}"); using (var stream = File.Open(outputFile, FileMode.Create)) { builder.Save(stream); } Console.WriteLine("Succesfully promoted package"); }
private void AssertMetadata(ManifestMetadata metadata) { var package = GetPkg(); Assert.IsNotNull(package); Assert.AreEqual(metadata.Id, package.Id); Assert.AreEqual(metadata.Version, package.Version.ToString()); Assert.AreEqual(metadata.Title, package.Title); CollectionAssert.AreEqual(metadata.Authors.Split(new[] { ',' }), package.Authors); CollectionAssert.AreEqual(metadata.Owners.Split(new[] { ',' }), package.Owners); Assert.AreEqual(metadata.Description, package.Description); Assert.AreEqual(metadata.ReleaseNotes, package.ReleaseNotes); Assert.AreEqual(metadata.Summary, package.Summary); Assert.AreEqual(metadata.Language, package.Language); Assert.AreEqual(metadata.ProjectUrl, package.ProjectUrl.ToString()); Assert.AreEqual(metadata.IconUrl, package.IconUrl.ToString()); Assert.AreEqual(metadata.LicenseUrl, package.LicenseUrl.ToString()); Assert.AreEqual(metadata.Copyright, package.Copyright); Assert.AreEqual(metadata.RequireLicenseAcceptance, package.RequireLicenseAcceptance); //dependencies //references //frameworkAssemblies Assert.AreEqual(metadata.Tags, package.Tags.SafeTrim()); Assert.AreEqual(metadata.DevelopmentDependency, package.DevelopmentDependency); }
public void Execute(string[] commandLineArguments) { optionGroups.Parse(commandLineArguments); if (string.IsNullOrWhiteSpace(id)) { throw new CommandException("An ID is required"); } if (includes.All(string.IsNullOrWhiteSpace)) { includes.Add("**"); } if (string.IsNullOrWhiteSpace(basePath)) { basePath = Path.GetFullPath(Environment.CurrentDirectory); } if (string.IsNullOrWhiteSpace(outFolder)) { outFolder = Path.GetFullPath(Environment.CurrentDirectory); } if (version == null) { var now = DateTime.Now; version = new SemanticVersion(now.Year, now.Month, now.Day, now.Hour * 10000 + now.Minute * 100 + now.Second); } if (authors.All(string.IsNullOrWhiteSpace)) { authors.Add(Environment.UserName + "@" + Environment.UserDomainName); } if (string.IsNullOrWhiteSpace(description)) { description = "A deployment package created from files on disk."; } string allReleaseNotes = null; if (!string.IsNullOrWhiteSpace(releaseNotesFile)) { if (!File.Exists(releaseNotesFile)) { log.Warning("The release notes file '{0}' could not be found", releaseNotesFile); } else { allReleaseNotes = fileSystem.ReadFile(releaseNotesFile); } } if (!string.IsNullOrWhiteSpace(releaseNotes)) { if (allReleaseNotes != null) { allReleaseNotes += Environment.NewLine + releaseNotes; } else { allReleaseNotes = releaseNotes; } } var metadata = new ManifestMetadata { Id = id, Authors = authors, Description = description, Version = version.ToNuGetVersion(), }; if (!string.IsNullOrWhiteSpace(allReleaseNotes)) { metadata.ReleaseNotes = allReleaseNotes; } if (!string.IsNullOrWhiteSpace(title)) { metadata.Title = title; } log.Information("Packing {0} version {1}...", id, version); packageBuilder.BuildPackage(basePath, includes, metadata, outFolder, overwrite); log.Information("Done."); }