Refactor the build scripts

- Bifurcate Package and Publish targets to enable signing. - Move publish from bash/ps into c#. - Create multiple targets to create MSIs and Bundles.
2016-03-07 12:20:50 -08:00 · 2016-03-07 12:20:50 -08:00 · d4a3190bfc
commit d4a3190bfc
parent 781678de92
25 changed files with 754 additions and 577 deletions
--- a/scripts/dotnet-cli-build/PackageTargets.cs
+++ b/scripts/dotnet-cli-build/PackageTargets.cs
@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.Cli.Build.Framework;
+using Microsoft.Extensions.PlatformAbstractions;
+
+using static Microsoft.DotNet.Cli.Build.Framework.BuildHelpers;
+
+namespace Microsoft.DotNet.Cli.Build
+{
+    public static class PackageTargets
+    {
+        [Target]
+        public static BuildTargetResult InitPackage(BuildTargetContext c)
+        {
+            Directory.CreateDirectory(Dirs.Packages);
+            return c.Success();
+        }
+
+        [Target(nameof(PrepareTargets.Init),
+        nameof(PackageTargets.InitPackage),
+        nameof(PackageTargets.GenerateVersionBadge),
+        nameof(PackageTargets.GenerateCompressedFile),
+        nameof(InstallerTargets.GenerateInstaller),
+        nameof(PackageTargets.GenerateNugetPackages))]
+        [Environment("DOTNET_BUILD_SKIP_PACKAGING", null)]
+        public static BuildTargetResult Package(BuildTargetContext c)
+        {
+            return c.Success();
+        }
+
+        [Target]
+        public static BuildTargetResult GenerateVersionBadge(BuildTargetContext c)
+        {
+            var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion");
+            var versionSvg = Path.Combine(Dirs.RepoRoot, "resources", "images", "version_badge.svg");
+            var outputVersionSvg = c.BuildContext.Get<string>("VersionBadge");
+
+            var versionSvgContent = File.ReadAllText(versionSvg);
+            versionSvgContent = versionSvgContent.Replace("ver_number", buildVersion.SimpleVersion);
+            File.WriteAllText(outputVersionSvg, versionSvgContent);
+
+            return c.Success();
+        }
+
+        [Target(nameof(PackageTargets.GenerateZip), nameof(PackageTargets.GenerateTarBall))]
+        public static BuildTargetResult GenerateCompressedFile(BuildTargetContext c)
+        {
+            return c.Success();
+        }
+
+        [Target(nameof(PackageTargets.InitPackage))]
+        [BuildPlatforms(BuildPlatform.Windows)]
+        public static BuildTargetResult GenerateZip(BuildTargetContext c)
+        {
+            var zipFile = c.BuildContext.Get<string>("CompressedFile");
+
+            if (File.Exists(zipFile))
+            {
+                File.Delete(zipFile);
+            }
+
+            ZipFile.CreateFromDirectory(Dirs.Stage2, zipFile, CompressionLevel.Optimal, false);
+            return c.Success();
+        }
+
+        [Target(nameof(PackageTargets.InitPackage))]
+        [BuildPlatforms(BuildPlatform.Unix)]
+        public static BuildTargetResult GenerateTarBall(BuildTargetContext c)
+        {
+            var tarFile = c.BuildContext.Get<string>("CompressedFile");
+
+            if (File.Exists(tarFile))
+            {
+                File.Delete(tarFile);
+            }
+
+            Cmd("tar", "-czf", tarFile, "-C", Dirs.Stage2, ".")
+                .Execute()
+                .EnsureSuccessful();
+            return c.Success();
+        }
+
+        [Target]
+        [BuildPlatforms(BuildPlatform.Windows)]
+        public static BuildTargetResult GenerateNugetPackages(BuildTargetContext c)
+        {
+            var versionSuffix = c.BuildContext.Get<BuildVersion>("BuildVersion").VersionSuffix;
+            var env = GetCommonEnvVars(c);
+            Cmd("powershell", "-NoProfile", "-NoLogo",
+                Path.Combine(Dirs.RepoRoot, "packaging", "nuget", "package.ps1"), Path.Combine(Dirs.Stage2, "bin"), versionSuffix)
+                    .Environment(env)
+                    .Execute()
+                    .EnsureSuccessful();
+            return c.Success();
+        }
+
+        internal static Dictionary<string, string> GetCommonEnvVars(BuildTargetContext c)
+        {
+            // Set up the environment variables previously defined by common.sh/ps1
+            // This is overkill, but I want to cover all the variables used in all OSes (including where some have the same names)
+            var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion");
+            var configuration = c.BuildContext.Get<string>("Configuration");
+            var architecture = PlatformServices.Default.Runtime.RuntimeArchitecture;
+            var env = new Dictionary<string, string>()
+            {
+                { "RID", PlatformServices.Default.Runtime.GetRuntimeIdentifier() },
+                { "OSNAME", PlatformServices.Default.Runtime.OperatingSystem },
+                { "TFM", "dnxcore50" },
+                { "REPOROOT", Dirs.RepoRoot },
+                { "OutputDir", Dirs.Output },
+                { "Stage1Dir", Dirs.Stage1 },
+                { "Stage1CompilationDir", Dirs.Stage1Compilation },
+                { "Stage2Dir", Dirs.Stage2 },
+                { "STAGE2_DIR", Dirs.Stage2 },
+                { "Stage2CompilationDir", Dirs.Stage2Compilation },
+                { "HostDir", Dirs.Corehost },
+                { "PackageDir", Path.Combine(Dirs.Packages) }, // Legacy name
+                { "TestBinRoot", Dirs.TestOutput },
+                { "TestPackageDir", Dirs.TestPackages },
+                { "MajorVersion", buildVersion.Major.ToString() },
+                { "MinorVersion", buildVersion.Minor.ToString() },
+                { "PatchVersion", buildVersion.Patch.ToString() },
+                { "CommitCountVersion", buildVersion.CommitCountString },
+                { "COMMIT_COUNT_VERSION", buildVersion.CommitCountString },
+                { "DOTNET_CLI_VERSION", buildVersion.SimpleVersion },
+                { "DOTNET_MSI_VERSION", buildVersion.GenerateMsiVersion() },
+                { "VersionSuffix", buildVersion.VersionSuffix },
+                { "CONFIGURATION", configuration },
+                { "ARCHITECTURE", architecture }
+            };
+
+            return env;
+        }
+    }
+}