mirrors/dotnet-installer
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Convert all CLI build targets to MSBuild Tasks. (#3690)

Browse source
This commit is contained in:
Eric Erhardt 2016-06-24 13:06:13 -05:00 • committed by Piotr Puszkiewicz
parent 0c9617559e
commit 15b2a9d9db
17 changed files with 687 additions and 565 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Microsoft.DotNet.Cli.sln
View file

@ -1,12 +1,13 @@
 
Microsoft Visual Studio Solution File, Format Version 12.00 Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14 # Visual Studio 14
VisualStudioVersion = 14.0.25123.0 VisualStudioVersion = 14.0.25402.0
MinimumVisualStudioVersion = 10.0.40219.1 MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{ED2FE3E2-F7E7-4389-8231-B65123F2076F}" Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{ED2FE3E2-F7E7-4389-8231-B65123F2076F}"
EndProject EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5A29E8E3-A0FC-4C57-81DD-297B56D1A119}" Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5A29E8E3-A0FC-4C57-81DD-297B56D1A119}"
ProjectSection(SolutionItems) = preProject ProjectSection(SolutionItems) = preProject
build.proj = build.proj
global.json = global.json global.json = global.json
NuGet.Config = NuGet.Config NuGet.Config = NuGet.Config
EndProjectSection EndProjectSection

29
build.proj
View file

@ -11,39 +11,44 @@
<PlatformScriptExtension Condition=" '$(OS)' == 'Windows_NT' ">.ps1</PlatformScriptExtension> <PlatformScriptExtension Condition=" '$(OS)' == 'Windows_NT' ">.ps1</PlatformScriptExtension>
<PlatformScriptExtension Condition=" '$(OS)' != 'Windows_NT' ">.sh</PlatformScriptExtension> <PlatformScriptExtension Condition=" '$(OS)' != 'Windows_NT' ">.sh</PlatformScriptExtension>
<PlatformExeExtension Condition=" '$(OS)' == 'Windows_NT' ">.exe</PlatformExeExtension> <NoRunArg Condition=" '$(OS)' == 'Windows_NT' ">-NoRun</NoRunArg>
<PlatformExeExtension Condition=" '$(OS)' != 'Windows_NT' "></PlatformExeExtension> <NoRunArg Condition=" '$(OS)' != 'Windows_NT' ">--norun</NoRunArg>
<CLITargets Condition=" '$(CLITargets)' == '' ">Prepare;Compile;Test;Package;Publish</CLITargets> <CLITargets Condition=" '$(CLITargets)' == '' ">Prepare;Compile;Test;Package;Publish</CLITargets>
<CLIBuildFileName>$(MSBuildThisFileDirectory)/build_projects/dotnet-cli-build/bin/dotnet-cli-build</CLIBuildFileName>
<CLIBuildDll>$(CLIBuildFileName).dll</CLIBuildDll>
</PropertyGroup> </PropertyGroup>
<Target Name="BuildDotnetCliBuildFramework" Inputs="" Outputs=""> <Target Name="BuildDotnetCliBuildFramework" Inputs="" Outputs="">
<Exec Command="$(PlatformScriptHost) $(MSBuildThisFileDirectory)/build_projects/dotnet-cli-build/build$(PlatformScriptExtension)" WorkingDirectory="$(MSBuildThisFileDirectory)"/> <Exec Command="$(PlatformScriptHost) $(MSBuildThisFileDirectory)/build_projects/dotnet-cli-build/build$(PlatformScriptExtension) $(NoRunArg)" WorkingDirectory="$(MSBuildThisFileDirectory)"/>
<PropertyGroup>
<CliBuildFrameworkExe>$(MSBuildThisFileDirectory)/build_projects/dotnet-cli-build/bin/dotnet-cli-build$(PlatformExeExtension)</CliBuildFrameworkExe>
</PropertyGroup>
</Target> </Target>
<Target DependsOnTargets="BuildDotnetCliBuildFramework;$(CLITargets)" Name="BuildTheWholeCli"></Target> <Target DependsOnTargets="$(CLITargets)" Name="BuildTheWholeCli"></Target>
<UsingTask TaskName="PrepareTargets" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="CompileTargets" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="TestTargets" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="PackageTargets" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="PublishTargets" AssemblyFile="$(CLIBuildDll)" />
<Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Prepare"> <Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Prepare">
<Exec Command="$(CliBuildFrameworkExe) Prepare" WorkingDirectory="$(MSBuildThisFileDirectory)"/> <PrepareTargets />
</Target> </Target>
<Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Compile"> <Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Compile">
<Exec Command="$(CliBuildFrameworkExe) Compile" WorkingDirectory="$(MSBuildThisFileDirectory)" /> <CompileTargets />
</Target> </Target>
<Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Test"> <Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Test">
<Exec Command="$(CliBuildFrameworkExe) Test" WorkingDirectory="$(MSBuildThisFileDirectory)" /> <TestTargets />
</Target> </Target>
<Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Package"> <Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Package">
<Exec Command="$(CliBuildFrameworkExe) Package" WorkingDirectory="$(MSBuildThisFileDirectory)" /> <PackageTargets />
</Target> </Target>
<Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Publish"> <Target DependsOnTargets="BuildDotnetCliBuildFramework" Name="Publish">
<Exec Command="$(CliBuildFrameworkExe) Publish" WorkingDirectory="$(MSBuildThisFileDirectory)" /> <PublishTargets />
</Target> </Target>
</Project> </Project>

7
build_projects/Microsoft.DotNet.Cli.Build.Framework/BuildSetup.cs
View file

@ -50,6 +50,11 @@ namespace Microsoft.DotNet.Cli.Build.Framework
return UseTargets(CollectTargets(typeof(T))); return UseTargets(CollectTargets(typeof(T)));
} }
public BuildContext CreateBuildContext()
{
return new BuildContext(_targets, Directory.GetCurrentDirectory());
}
public int Run(string[] args) public int Run(string[] args)
{ {
var targets = new[] { BuildContext.DefaultTarget }; var targets = new[] { BuildContext.DefaultTarget };
@ -68,7 +73,7 @@ namespace Microsoft.DotNet.Cli.Build.Framework
} }
} }
var context = new BuildContext(_targets, Directory.GetCurrentDirectory()); var context = CreateBuildContext();
BuildTargetResult result = null; BuildTargetResult result = null;
try try
{ {

6
build_projects/Microsoft.DotNet.Cli.Build.Framework/CurrentPlatform.cs
View file

@ -1,4 +1,5 @@
using System; using System;
using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using Microsoft.DotNet.InternalAbstractions; using Microsoft.DotNet.InternalAbstractions;
@ -105,6 +106,11 @@ namespace Microsoft.DotNet.Cli.Build.Framework
return IsPlatform(platform) && (version == null || IsVersion(version)); return IsPlatform(platform) && (version == null || IsVersion(version));
} }
public static bool IsAnyPlatform(params BuildPlatform[] platforms)
{
return platforms.Any(p => IsPlatform(p));
}
public static bool IsPlatform(BuildPlatform platform) public static bool IsPlatform(BuildPlatform platform)
{ {
switch (platform) switch (platform)

23
build_projects/dotnet-cli-build/CompileTargets.cs
View file

@ -1,9 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using Microsoft.Build.Utilities;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.DotNet.Cli.Build.Framework; using Microsoft.DotNet.Cli.Build.Framework;
using Microsoft.DotNet.InternalAbstractions; using Microsoft.DotNet.InternalAbstractions;
using Newtonsoft.Json; using Newtonsoft.Json;
@ -13,7 +11,7 @@ using static Microsoft.DotNet.Cli.Build.FS;
namespace Microsoft.DotNet.Cli.Build namespace Microsoft.DotNet.Cli.Build
{ {
public class CompileTargets public class CompileTargets : Task
{ {
public static readonly bool IsWinx86 = CurrentPlatform.IsWindows && CurrentArchitecture.Isx86; public static readonly bool IsWinx86 = CurrentPlatform.IsWindows && CurrentArchitecture.Isx86;
@ -58,20 +56,24 @@ namespace Microsoft.DotNet.Cli.Build
public static Crossgen CrossgenUtil = new Crossgen(DependencyVersions.CoreCLRVersion, DependencyVersions.JitVersion); public static Crossgen CrossgenUtil = new Crossgen(DependencyVersions.CoreCLRVersion, DependencyVersions.JitVersion);
// Updates the stage 2 with recent changes. public override bool Execute()
[Target(nameof(PrepareTargets.Init), nameof(CompileStage2))]
public static BuildTargetResult UpdateBuild(BuildTargetContext c)
{ {
return c.Success(); BuildContext context = new BuildSetup("MSBuild").UseAllTargetsFromAssembly<CompileTargets>().CreateBuildContext();
BuildTargetContext c = new BuildTargetContext(context, null, null);
return Compile(c).Success;
} }
[Target(nameof(PrepareTargets.Init), nameof(CompileStage1), nameof(CompileStage2))] [Target]
public static BuildTargetResult Compile(BuildTargetContext c) public static BuildTargetResult Compile(BuildTargetContext c)
{ {
PrepareTargets.Init(c);
CompileStage1(c);
CompileStage2(c);
return c.Success(); return c.Success();
} }
[Target(nameof(PrepareTargets.Init))]
public static BuildTargetResult CompileStage1(BuildTargetContext c) public static BuildTargetResult CompileStage1(BuildTargetContext c)
{ {
CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src"));
@ -94,7 +96,6 @@ namespace Microsoft.DotNet.Cli.Build
return result; return result;
} }
[Target(nameof(PrepareTargets.Init))]
public static BuildTargetResult CompileStage2(BuildTargetContext c) public static BuildTargetResult CompileStage2(BuildTargetContext c)
{ {
var configuration = c.BuildContext.Get<string>("Configuration"); var configuration = c.BuildContext.Get<string>("Configuration");

190
build_projects/dotnet-cli-build/DebTargets.cs
View file

@ -12,71 +12,80 @@ namespace Microsoft.DotNet.Cli.Build
{ {
public class DebTargets public class DebTargets
{ {
[Target(nameof(GenerateSdkDeb))]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult GenerateDebs(BuildTargetContext c) public static BuildTargetResult GenerateDebs(BuildTargetContext c)
{ {
if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
{
GenerateSdkDeb(c);
}
return c.Success(); return c.Success();
} }
[Target(nameof(InstallSharedFramework))]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult GenerateSdkDeb(BuildTargetContext c) public static BuildTargetResult GenerateSdkDeb(BuildTargetContext c)
{ {
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
// So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167
if (DebuildNotPresent())
{ {
c.Info("Debuild not present, skipping target: {nameof(RemovePackages)}"); InstallSharedFramework(c);
return c.Success();
}
var channel = c.BuildContext.Get<string>("Channel").ToLower();
var packageName = CliMonikers.GetSdkDebianPackageName(c);
var version = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion;
var debFile = c.BuildContext.Get<string>("SdkInstallerFile");
var manPagesDir = Path.Combine(Dirs.RepoRoot, "Documentation", "manpages");
var previousVersionURL = $"https://dotnetcli.blob.core.windows.net/dotnet/{channel}/Installers/Latest/dotnet-ubuntu-x64.latest.deb";
var sdkPublishRoot = c.BuildContext.Get<string>("CLISDKRoot");
var sharedFxDebianPackageName = Monikers.GetDebianSharedFrameworkPackageName(CliDependencyVersions.SharedFrameworkVersion);
var objRoot = Path.Combine(Dirs.Output, "obj", "debian", "sdk"); // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
// So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167
if (DebuildNotPresent())
{
c.Info("Debuild not present, skipping target: {nameof(RemovePackages)}");
return c.Success();
}
if (Directory.Exists(objRoot)) var channel = c.BuildContext.Get<string>("Channel").ToLower();
{ var packageName = CliMonikers.GetSdkDebianPackageName(c);
Directory.Delete(objRoot, true); var version = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion;
var debFile = c.BuildContext.Get<string>("SdkInstallerFile");
var manPagesDir = Path.Combine(Dirs.RepoRoot, "Documentation", "manpages");
var previousVersionURL = $"https://dotnetcli.blob.core.windows.net/dotnet/{channel}/Installers/Latest/dotnet-ubuntu-x64.latest.deb";
var sdkPublishRoot = c.BuildContext.Get<string>("CLISDKRoot");
var sharedFxDebianPackageName = Monikers.GetDebianSharedFrameworkPackageName(CliDependencyVersions.SharedFrameworkVersion);
var objRoot = Path.Combine(Dirs.Output, "obj", "debian", "sdk");
if (Directory.Exists(objRoot))
{
Directory.Delete(objRoot, true);
}
Directory.CreateDirectory(objRoot);
Cmd(Path.Combine(Dirs.RepoRoot, "scripts", "package", "package-debian.sh"),
"-v", version,
"-i", sdkPublishRoot,
"-o", debFile,
"-p", packageName,
"-b", Monikers.CLISdkBrandName,
"-m", manPagesDir,
"--framework-debian-package-name", sharedFxDebianPackageName,
"--framework-nuget-name", Monikers.SharedFrameworkName,
"--framework-nuget-version", CliDependencyVersions.SharedFrameworkVersion,
"--previous-version-url", previousVersionURL,
"--obj-root", objRoot)
.Execute()
.EnsureSuccessful();
} }
Directory.CreateDirectory(objRoot);
Cmd(Path.Combine(Dirs.RepoRoot, "scripts", "package", "package-debian.sh"),
"-v", version,
"-i", sdkPublishRoot,
"-o", debFile,
"-p", packageName,
"-b", Monikers.CLISdkBrandName,
"-m", manPagesDir,
"--framework-debian-package-name", sharedFxDebianPackageName,
"--framework-nuget-name", Monikers.SharedFrameworkName,
"--framework-nuget-version", CliDependencyVersions.SharedFrameworkVersion,
"--previous-version-url", previousVersionURL,
"--obj-root", objRoot)
.Execute()
.EnsureSuccessful();
return c.Success(); return c.Success();
} }
[Target(nameof(InstallSDK),
nameof(RunE2ETest),
nameof(RemovePackages))]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult TestDebInstaller(BuildTargetContext c) public static BuildTargetResult TestDebInstaller(BuildTargetContext c)
{ {
if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
{
InstallSDK(c);
RunE2ETest(c);
RemovePackages(c);
}
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult InstallSharedHost(BuildTargetContext c) public static BuildTargetResult InstallSharedHost(BuildTargetContext c)
{ {
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
@ -93,9 +102,10 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target(nameof(InstallSharedHost))]
public static BuildTargetResult InstallHostFxr(BuildTargetContext c) public static BuildTargetResult InstallHostFxr(BuildTargetContext c)
{ {
InstallSharedHost(c);
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
// So we need to skip this target if the tools aren't present. // So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167 // https://github.com/dotnet/core-setup/issues/167
@ -110,9 +120,10 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target(nameof(InstallHostFxr))]
public static BuildTargetResult InstallSharedFramework(BuildTargetContext c) public static BuildTargetResult InstallSharedFramework(BuildTargetContext c)
{ {
InstallHostFxr(c);
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
// So we need to skip this target if the tools aren't present. // So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167 // https://github.com/dotnet/core-setup/issues/167
@ -127,9 +138,10 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target(nameof(InstallSharedFramework))]
public static BuildTargetResult InstallSDK(BuildTargetContext c) public static BuildTargetResult InstallSDK(BuildTargetContext c)
{ {
InstallSharedFramework(c);
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
// So we need to skip this target if the tools aren't present. // So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167 // https://github.com/dotnet/core-setup/issues/167
@ -144,58 +156,60 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult RunE2ETest(BuildTargetContext c) public static BuildTargetResult RunE2ETest(BuildTargetContext c)
{ {
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
// So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167
if (DebuildNotPresent())
{ {
c.Info("Debuild not present, skipping target: {nameof(RemovePackages)}"); // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
return c.Success(); // So we need to skip this target if the tools aren't present.
} // https://github.com/dotnet/core-setup/issues/167
if (DebuildNotPresent())
{
c.Info("Debuild not present, skipping target: {nameof(RemovePackages)}");
return c.Success();
}
Directory.SetCurrentDirectory(Path.Combine(Dirs.RepoRoot, "test", "EndToEnd")); Directory.SetCurrentDirectory(Path.Combine(Dirs.RepoRoot, "test", "EndToEnd"));
Cmd("dotnet", "build") Cmd("dotnet", "build")
.Execute() .Execute()
.EnsureSuccessful(); .EnsureSuccessful();
var testResultsPath = Path.Combine(Dirs.Output, "obj", "debian", "test", "debian-endtoend-testResults.xml"); var testResultsPath = Path.Combine(Dirs.Output, "obj", "debian", "test", "debian-endtoend-testResults.xml");
Cmd("dotnet", "test", "-xml", testResultsPath) Cmd("dotnet", "test", "-xml", testResultsPath)
.Execute() .Execute()
.EnsureSuccessful(); .EnsureSuccessful();
}
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult RemovePackages(BuildTargetContext c) public static BuildTargetResult RemovePackages(BuildTargetContext c)
{ {
// Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
// So we need to skip this target if the tools aren't present.
// https://github.com/dotnet/core-setup/issues/167
if (DebuildNotPresent())
{ {
c.Info("Debuild not present, skipping target: {nameof(RemovePackages)}"); // Ubuntu 16.04 Jenkins Machines don't have docker or debian package build tools
return c.Success(); // So we need to skip this target if the tools aren't present.
} // https://github.com/dotnet/core-setup/issues/167
if (DebuildNotPresent())
{
c.Info("Debuild not present, skipping target: {nameof(RemovePackages)}");
return c.Success();
}
IEnumerable<string> orderedPackageNames = new List<string>() IEnumerable<string> orderedPackageNames = new List<string>()
{ {
CliMonikers.GetSdkDebianPackageName(c), CliMonikers.GetSdkDebianPackageName(c),
Monikers.GetDebianSharedFrameworkPackageName(CliDependencyVersions.SharedFrameworkVersion), Monikers.GetDebianSharedFrameworkPackageName(CliDependencyVersions.SharedFrameworkVersion),
Monikers.GetDebianHostFxrPackageName(CliDependencyVersions.HostFxrVersion), Monikers.GetDebianHostFxrPackageName(CliDependencyVersions.HostFxrVersion),
Monikers.GetDebianSharedHostPackageName(c) Monikers.GetDebianSharedHostPackageName(c)
}; };
foreach(var packageName in orderedPackageNames) foreach (var packageName in orderedPackageNames)
{ {
RemovePackage(packageName); RemovePackage(packageName);
}
} }
return c.Success(); return c.Success();

12
build_projects/dotnet-cli-build/InstallerTargets.cs
View file

@ -4,19 +4,19 @@ namespace Microsoft.DotNet.Cli.Build
{ {
public class InstallerTargets public class InstallerTargets
{ {
[Target(nameof(MsiTargets.GenerateMsis),
nameof(MsiTargets.GenerateBundles),
nameof(PkgTargets.GeneratePkgs),
nameof(DebTargets.GenerateDebs))]
public static BuildTargetResult GenerateInstaller(BuildTargetContext c) public static BuildTargetResult GenerateInstaller(BuildTargetContext c)
{ {
MsiTargets.GenerateMsisAndBundles(c);
PkgTargets.GeneratePkgs(c);
DebTargets.GenerateDebs(c);
return c.Success(); return c.Success();
} }
[Target(nameof(DebTargets.TestDebInstaller))]
public static BuildTargetResult TestInstaller(BuildTargetContext c) public static BuildTargetResult TestInstaller(BuildTargetContext c)
{ {
DebTargets.TestDebInstaller(c);
return c.Success(); return c.Success();
} }
} }

95
build_projects/dotnet-cli-build/MsiTargets.cs
View file

@ -75,75 +75,78 @@ namespace Microsoft.DotNet.Cli.Build
} }
} }
[Target]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult InitMsi(BuildTargetContext c) public static BuildTargetResult InitMsi(BuildTargetContext c)
{ {
SdkBundle = c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile"); if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
SdkMsi = Path.ChangeExtension(SdkBundle, "msi"); {
SdkEngine = GetEngineName(SdkBundle); SdkBundle = c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile");
SdkMsi = Path.ChangeExtension(SdkBundle, "msi");
SdkEngine = GetEngineName(SdkBundle);
SharedFrameworkMsi = Path.ChangeExtension(c.BuildContext.Get<string>("SharedFrameworkInstallerFile"), "msi"); SharedFrameworkMsi = Path.ChangeExtension(c.BuildContext.Get<string>("SharedFrameworkInstallerFile"), "msi");
HostFxrMsi = Path.ChangeExtension(c.BuildContext.Get<string>("HostFxrInstallerFile"), "msi"); HostFxrMsi = Path.ChangeExtension(c.BuildContext.Get<string>("HostFxrInstallerFile"), "msi");
SharedHostMsi = Path.ChangeExtension(c.BuildContext.Get<string>("SharedHostInstallerFile"), "msi"); SharedHostMsi = Path.ChangeExtension(c.BuildContext.Get<string>("SharedHostInstallerFile"), "msi");
var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion"); var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion");
MsiVersion = buildVersion.GenerateMsiVersion(); MsiVersion = buildVersion.GenerateMsiVersion();
CliDisplayVersion = buildVersion.SimpleVersion; CliDisplayVersion = buildVersion.SimpleVersion;
CliNugetVersion = buildVersion.NuGetVersion; CliNugetVersion = buildVersion.NuGetVersion;
AcquireWix(c);
}
AcquireWix(c);
return c.Success(); return c.Success();
} }
public static BuildTargetResult GenerateMsisAndBundles(BuildTargetContext c)
[Target(nameof(MsiTargets.InitMsi),
nameof(GenerateCliSdkMsi))]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult GenerateMsis(BuildTargetContext c)
{ {
if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
{
InitMsi(c);
GenerateCliSdkMsi(c);
GenerateCliSdkBundle(c);
}
return c.Success(); return c.Success();
} }
[Target(nameof(MsiTargets.InitMsi),
nameof(GenerateCliSdkBundle))]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult GenerateBundles(BuildTargetContext c)
{
return c.Success();
}
[Target]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult GenerateCliSdkMsi(BuildTargetContext c) public static BuildTargetResult GenerateCliSdkMsi(BuildTargetContext c)
{ {
var cliSdkRoot = c.BuildContext.Get<string>("CLISDKRoot"); if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
var upgradeCode = Utils.GenerateGuidFromName(SdkMsi).ToString().ToUpper(); {
var cliSdkBrandName = $"'{Monikers.CLISdkBrandName}'"; var cliSdkRoot = c.BuildContext.Get<string>("CLISDKRoot");
var upgradeCode = Utils.GenerateGuidFromName(SdkMsi).ToString().ToUpper();
var cliSdkBrandName = $"'{Monikers.CLISdkBrandName}'";
Cmd("powershell", "-NoProfile", "-NoLogo",
Path.Combine(Dirs.RepoRoot, "packaging", "windows", "clisdk", "generatemsi.ps1"),
cliSdkRoot, SdkMsi, WixRoot, cliSdkBrandName, MsiVersion, CliDisplayVersion, CliNugetVersion, upgradeCode, Arch)
.Execute()
.EnsureSuccessful();
}
Cmd("powershell", "-NoProfile", "-NoLogo",
Path.Combine(Dirs.RepoRoot, "packaging", "windows", "clisdk", "generatemsi.ps1"),
cliSdkRoot, SdkMsi, WixRoot, cliSdkBrandName, MsiVersion, CliDisplayVersion, CliNugetVersion, upgradeCode, Arch)
.Execute()
.EnsureSuccessful();
return c.Success(); return c.Success();
} }
[Target(nameof(MsiTargets.InitMsi))]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult GenerateCliSdkBundle(BuildTargetContext c) public static BuildTargetResult GenerateCliSdkBundle(BuildTargetContext c)
{ {
var upgradeCode = Utils.GenerateGuidFromName(SdkBundle).ToString().ToUpper(); if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
var cliSdkBrandName = $"'{Monikers.CLISdkBrandName}'"; {
var upgradeCode = Utils.GenerateGuidFromName(SdkBundle).ToString().ToUpper();
var cliSdkBrandName = $"'{Monikers.CLISdkBrandName}'";
Cmd("powershell", "-NoProfile", "-NoLogo",
Path.Combine(Dirs.RepoRoot, "packaging", "windows", "clisdk", "generatebundle.ps1"),
SdkMsi, SharedFrameworkMsi, HostFxrMsi, SharedHostMsi, SdkBundle, WixRoot, cliSdkBrandName, MsiVersion, CliDisplayVersion, CliNugetVersion, upgradeCode, Arch)
.EnvironmentVariable("Stage2Dir", Dirs.Stage2)
.Execute()
.EnsureSuccessful();
}
Cmd("powershell", "-NoProfile", "-NoLogo",
Path.Combine(Dirs.RepoRoot, "packaging", "windows", "clisdk", "generatebundle.ps1"),
SdkMsi, SharedFrameworkMsi, HostFxrMsi, SharedHostMsi, SdkBundle, WixRoot, cliSdkBrandName, MsiVersion, CliDisplayVersion, CliNugetVersion, upgradeCode, Arch)
.EnvironmentVariable("Stage2Dir", Dirs.Stage2)
.Execute()
.EnsureSuccessful();
return c.Success(); return c.Success();
} }
// TODO: The following "Engine" tasks need to be separate MSBuild targets so the Windows
// VSO build can invoke them directly for signing.
[Target(nameof(MsiTargets.InitMsi))] [Target(nameof(MsiTargets.InitMsi))]
[BuildPlatforms(BuildPlatform.Windows)] [BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult ExtractEngineFromBundle(BuildTargetContext c) public static BuildTargetResult ExtractEngineFromBundle(BuildTargetContext c)

76
build_projects/dotnet-cli-build/PackageTargets.cs
View file

@ -3,13 +3,14 @@ using System.Collections.Generic;
using System.IO; using System.IO;
using System.IO.Compression; using System.IO.Compression;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using Microsoft.Build.Utilities;
using Microsoft.DotNet.Cli.Build.Framework; using Microsoft.DotNet.Cli.Build.Framework;
using Microsoft.DotNet.InternalAbstractions; using Microsoft.DotNet.InternalAbstractions;
using static Microsoft.DotNet.Cli.Build.Framework.BuildHelpers; using static Microsoft.DotNet.Cli.Build.Framework.BuildHelpers;
namespace Microsoft.DotNet.Cli.Build namespace Microsoft.DotNet.Cli.Build
{ {
public static class PackageTargets public class PackageTargets : Task
{ {
public static readonly string[] ProjectsToPack = new string[] public static readonly string[] ProjectsToPack = new string[]
{ {
@ -26,32 +27,44 @@ namespace Microsoft.DotNet.Cli.Build
"Microsoft.Extensions.Testing.Abstractions" "Microsoft.Extensions.Testing.Abstractions"
}; };
[Target(nameof(PackageTargets.CopyCLISDKLayout), public override bool Execute()
nameof(PackageTargets.CopySharedHostLayout), {
nameof(PackageTargets.CopyHostFxrLayout), BuildContext context = new BuildSetup("MSBuild").UseAllTargetsFromAssembly<PackageTargets>().CreateBuildContext();
nameof(PackageTargets.CopySharedFxLayout), BuildTargetContext c = new BuildTargetContext(context, null, null);
nameof(PackageTargets.CopyCombinedFrameworkSDKHostLayout),
nameof(PackageTargets.CopyCombinedFrameworkSDKLayout))] return Package(c).Success;
}
public static BuildTargetResult InitPackage(BuildTargetContext c) public static BuildTargetResult InitPackage(BuildTargetContext c)
{ {
CopyCLISDKLayout(c);
CopySharedHostLayout(c);
CopyHostFxrLayout(c);
CopySharedFxLayout(c);
CopyCombinedFrameworkSDKHostLayout(c);
CopyCombinedFrameworkSDKLayout(c);
Directory.CreateDirectory(Dirs.Packages); Directory.CreateDirectory(Dirs.Packages);
return c.Success(); return c.Success();
} }
[Target(nameof(PrepareTargets.Init), [Target]
nameof(PackageTargets.InitPackage),
nameof(PackageTargets.GenerateVersionBadge),
nameof(PackageTargets.GenerateCompressedFile),
nameof(InstallerTargets.GenerateInstaller),
nameof(PackageTargets.GenerateNugetPackages),
nameof(InstallerTargets.TestInstaller))]
[Environment("DOTNET_BUILD_SKIP_PACKAGING", null, "0", "false")]
public static BuildTargetResult Package(BuildTargetContext c) public static BuildTargetResult Package(BuildTargetContext c)
{ {
if (!EnvVars.GetBool("DOTNET_BUILD_SKIP_PACKAGING"))
{
PrepareTargets.Init(c);
InitPackage(c);
GenerateVersionBadge(c);
GenerateCompressedFile(c);
InstallerTargets.GenerateInstaller(c);
GenerateNugetPackages(c);
InstallerTargets.TestInstaller(c);
}
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult GenerateVersionBadge(BuildTargetContext c) public static BuildTargetResult GenerateVersionBadge(BuildTargetContext c)
{ {
var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion"); var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion");
@ -65,7 +78,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CopyCLISDKLayout(BuildTargetContext c) public static BuildTargetResult CopyCLISDKLayout(BuildTargetContext c)
{ {
var cliSdkRoot = Path.Combine(Dirs.Output, "obj", "clisdk"); var cliSdkRoot = Path.Combine(Dirs.Output, "obj", "clisdk");
@ -82,7 +94,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CopySharedHostLayout(BuildTargetContext c) public static BuildTargetResult CopySharedHostLayout(BuildTargetContext c)
{ {
var sharedHostRoot = Path.Combine(Dirs.Output, "obj", "sharedHost"); var sharedHostRoot = Path.Combine(Dirs.Output, "obj", "sharedHost");
@ -104,7 +115,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CopyHostFxrLayout(BuildTargetContext c) public static BuildTargetResult CopyHostFxrLayout(BuildTargetContext c)
{ {
var hostFxrRoot = Path.Combine(Dirs.Output, "obj", "hostFxr"); var hostFxrRoot = Path.Combine(Dirs.Output, "obj", "hostFxr");
@ -121,7 +131,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CopySharedFxLayout(BuildTargetContext c) public static BuildTargetResult CopySharedFxLayout(BuildTargetContext c)
{ {
var sharedFxRoot = Path.Combine(Dirs.Output, "obj", "sharedFx"); var sharedFxRoot = Path.Combine(Dirs.Output, "obj", "sharedFx");
@ -138,7 +147,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CopyCombinedFrameworkSDKHostLayout(BuildTargetContext c) public static BuildTargetResult CopyCombinedFrameworkSDKHostLayout(BuildTargetContext c)
{ {
var combinedRoot = Path.Combine(Dirs.Output, "obj", "combined-framework-sdk-host"); var combinedRoot = Path.Combine(Dirs.Output, "obj", "combined-framework-sdk-host");
@ -163,7 +171,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CopyCombinedFrameworkSDKLayout(BuildTargetContext c) public static BuildTargetResult CopyCombinedFrameworkSDKLayout(BuildTargetContext c)
{ {
var combinedRoot = Path.Combine(Dirs.Output, "obj", "combined-framework-sdk"); var combinedRoot = Path.Combine(Dirs.Output, "obj", "combined-framework-sdk");
@ -182,35 +189,38 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target(nameof(PackageTargets.GenerateZip), nameof(PackageTargets.GenerateTarBall))]
public static BuildTargetResult GenerateCompressedFile(BuildTargetContext c) public static BuildTargetResult GenerateCompressedFile(BuildTargetContext c)
{ {
GenerateZip(c);
GenerateTarBall(c);
return c.Success(); return c.Success();
} }
[Target(nameof(PackageTargets.InitPackage))]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult GenerateZip(BuildTargetContext c) public static BuildTargetResult GenerateZip(BuildTargetContext c)
{ {
CreateZipFromDirectory(c.BuildContext.Get<string>("CombinedFrameworkSDKHostRoot"), c.BuildContext.Get<string>("CombinedFrameworkSDKHostCompressedFile")); if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
CreateZipFromDirectory(c.BuildContext.Get<string>("CombinedFrameworkSDKRoot"), c.BuildContext.Get<string>("CombinedFrameworkSDKCompressedFile")); {
CreateZipFromDirectory(Path.Combine(Dirs.Stage2Symbols, "sdk"), c.BuildContext.Get<string>("SdkSymbolsCompressedFile")); CreateZipFromDirectory(c.BuildContext.Get<string>("CombinedFrameworkSDKHostRoot"), c.BuildContext.Get<string>("CombinedFrameworkSDKHostCompressedFile"));
CreateZipFromDirectory(c.BuildContext.Get<string>("CombinedFrameworkSDKRoot"), c.BuildContext.Get<string>("CombinedFrameworkSDKCompressedFile"));
CreateZipFromDirectory(Path.Combine(Dirs.Stage2Symbols, "sdk"), c.BuildContext.Get<string>("SdkSymbolsCompressedFile"));
}
return c.Success(); return c.Success();
} }
[Target(nameof(PackageTargets.InitPackage))]
[BuildPlatforms(BuildPlatform.Unix)]
public static BuildTargetResult GenerateTarBall(BuildTargetContext c) public static BuildTargetResult GenerateTarBall(BuildTargetContext c)
{ {
CreateTarBallFromDirectory(c.BuildContext.Get<string>("CombinedFrameworkSDKHostRoot"), c.BuildContext.Get<string>("CombinedFrameworkSDKHostCompressedFile")); if (CurrentPlatform.IsPlatform(BuildPlatform.Unix))
{
CreateTarBallFromDirectory(c.BuildContext.Get<string>("CombinedFrameworkSDKHostRoot"), c.BuildContext.Get<string>("CombinedFrameworkSDKHostCompressedFile"));
CreateTarBallFromDirectory(Path.Combine(Dirs.Stage2Symbols, "sdk"), c.BuildContext.Get<string>("SdkSymbolsCompressedFile")); CreateTarBallFromDirectory(Path.Combine(Dirs.Stage2Symbols, "sdk"), c.BuildContext.Get<string>("SdkSymbolsCompressedFile"));
}
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult GenerateNugetPackages(BuildTargetContext c) public static BuildTargetResult GenerateNugetPackages(BuildTargetContext c)
{ {
var versionSuffix = c.BuildContext.Get<BuildVersion>("BuildVersion").CommitCountString; var versionSuffix = c.BuildContext.Get<BuildVersion>("BuildVersion").CommitCountString;

145
build_projects/dotnet-cli-build/PkgTargets.cs
View file

@ -22,102 +22,111 @@ namespace Microsoft.DotNet.Cli.Build
public static string CLISdkNugetVersion { get; set; } public static string CLISdkNugetVersion { get; set; }
public static string HostFxrComponentId { get; set; } public static string HostFxrComponentId { get; set; }
[Target]
[BuildPlatforms(BuildPlatform.OSX)]
public static BuildTargetResult InitPkg(BuildTargetContext c) public static BuildTargetResult InitPkg(BuildTargetContext c)
{ {
PkgsIntermediateDir = Path.Combine(Dirs.Packages, "intermediate"); if (CurrentPlatform.IsPlatform(BuildPlatform.OSX))
Directory.CreateDirectory(PkgsIntermediateDir); {
PkgsIntermediateDir = Path.Combine(Dirs.Packages, "intermediate");
Directory.CreateDirectory(PkgsIntermediateDir);
SharedHostComponentId = $"com.microsoft.dotnet.sharedhost.component.osx.x64"; SharedHostComponentId = $"com.microsoft.dotnet.sharedhost.component.osx.x64";
HostFxrComponentId = $"com.microsoft.dotnet.hostfxr.component.osx.x64"; HostFxrComponentId = $"com.microsoft.dotnet.hostfxr.component.osx.x64";
string sharedFrameworkNugetName = Monikers.SharedFrameworkName; string sharedFrameworkNugetName = Monikers.SharedFrameworkName;
SharedFrameworkNugetVersion = CliDependencyVersions.SharedFrameworkVersion; SharedFrameworkNugetVersion = CliDependencyVersions.SharedFrameworkVersion;
SharedFxComponentId = $"com.microsoft.dotnet.sharedframework.{sharedFrameworkNugetName}.{SharedFrameworkNugetVersion}.component.osx.x64"; SharedFxComponentId = $"com.microsoft.dotnet.sharedframework.{sharedFrameworkNugetName}.{SharedFrameworkNugetVersion}.component.osx.x64";
SharedFxPkgId = $"com.microsoft.dotnet.{sharedFrameworkNugetName}.{SharedFrameworkNugetVersion}.osx.x64"; SharedFxPkgId = $"com.microsoft.dotnet.{sharedFrameworkNugetName}.{SharedFrameworkNugetVersion}.osx.x64";
CLISdkNugetVersion = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion; CLISdkNugetVersion = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion;
CLISdkComponentId = $"com.microsoft.dotnet.dev.{CLISdkNugetVersion}.component.osx.x64"; CLISdkComponentId = $"com.microsoft.dotnet.dev.{CLISdkNugetVersion}.component.osx.x64";
CLISdkPkgId = $"com.microsoft.dotnet.dev.{CLISdkNugetVersion}.osx.x64"; CLISdkPkgId = $"com.microsoft.dotnet.dev.{CLISdkNugetVersion}.osx.x64";
}
return c.Success(); return c.Success();
} }
[Target(nameof(InitPkg), nameof(GenerateCLISdkProductArchive))]
[BuildPlatforms(BuildPlatform.OSX)]
public static BuildTargetResult GeneratePkgs(BuildTargetContext c) public static BuildTargetResult GeneratePkgs(BuildTargetContext c)
{ {
if (CurrentPlatform.IsPlatform(BuildPlatform.OSX))
{
InitPkg(c);
GenerateCLISdkProductArchive(c);
}
return c.Success(); return c.Success();
} }
[Target(nameof(GenerateCLISdkPkg))]
[BuildPlatforms(BuildPlatform.OSX)]
public static BuildTargetResult GenerateCLISdkProductArchive(BuildTargetContext c) public static BuildTargetResult GenerateCLISdkProductArchive(BuildTargetContext c)
{ {
string resourcePath = Path.Combine(Dirs.RepoRoot, "packaging", "osx", "clisdk", "resources"); if (CurrentPlatform.IsPlatform(BuildPlatform.OSX))
string outFilePath = Path.Combine(Dirs.Packages, c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile")); {
GenerateCLISdkPkg(c);
// Copy SharedFX and host installers in the correct place string resourcePath = Path.Combine(Dirs.RepoRoot, "packaging", "osx", "clisdk", "resources");
var sharedFrameworkPkgIntermediatePath = Path.Combine(PkgsIntermediateDir, $"{SharedFxComponentId}.pkg"); string outFilePath = Path.Combine(Dirs.Packages, c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile"));
var sharedHostPkgIntermediatePath = Path.Combine(PkgsIntermediateDir, $"{SharedHostComponentId}.pkg");
var hostFxrPkgIntermediatePath = Path.Combine(PkgsIntermediateDir, $"{HostFxrComponentId}.pkg"); // Copy SharedFX and host installers in the correct place
var sharedFrameworkPkgIntermediatePath = Path.Combine(PkgsIntermediateDir, $"{SharedFxComponentId}.pkg");
var sharedHostPkgIntermediatePath = Path.Combine(PkgsIntermediateDir, $"{SharedHostComponentId}.pkg");
var hostFxrPkgIntermediatePath = Path.Combine(PkgsIntermediateDir, $"{HostFxrComponentId}.pkg");
File.Copy(c.BuildContext.Get<string>("SharedFrameworkInstallerFile"), sharedFrameworkPkgIntermediatePath, true); File.Copy(c.BuildContext.Get<string>("SharedFrameworkInstallerFile"), sharedFrameworkPkgIntermediatePath, true);
File.Copy(c.BuildContext.Get<string>("SharedHostInstallerFile"), sharedHostPkgIntermediatePath, true); File.Copy(c.BuildContext.Get<string>("SharedHostInstallerFile"), sharedHostPkgIntermediatePath, true);
File.Copy(c.BuildContext.Get<string>("HostFxrInstallerFile"), hostFxrPkgIntermediatePath, true); File.Copy(c.BuildContext.Get<string>("HostFxrInstallerFile"), hostFxrPkgIntermediatePath, true);
string inputDistTemplatePath = Path.Combine( string inputDistTemplatePath = Path.Combine(
Dirs.RepoRoot, Dirs.RepoRoot,
"packaging", "packaging",
"osx", "osx",
"clisdk", "clisdk",
"Distribution-Template"); "Distribution-Template");
string distTemplate = File.ReadAllText(inputDistTemplatePath); string distTemplate = File.ReadAllText(inputDistTemplatePath);
string distributionPath = Path.Combine(PkgsIntermediateDir, "CLI-SDK-Formatted-Distribution-Template.xml"); string distributionPath = Path.Combine(PkgsIntermediateDir, "CLI-SDK-Formatted-Distribution-Template.xml");
string formattedDistContents = string formattedDistContents =
distTemplate.Replace("{SharedFxComponentId}", SharedFxComponentId) distTemplate.Replace("{SharedFxComponentId}", SharedFxComponentId)
.Replace("{SharedHostComponentId}", SharedHostComponentId) .Replace("{SharedHostComponentId}", SharedHostComponentId)
.Replace("{HostFxrComponentId}", HostFxrComponentId) .Replace("{HostFxrComponentId}", HostFxrComponentId)
.Replace("{CLISdkComponentId}", CLISdkComponentId) .Replace("{CLISdkComponentId}", CLISdkComponentId)
.Replace("{CLISdkNugetVersion}", CLISdkNugetVersion) .Replace("{CLISdkNugetVersion}", CLISdkNugetVersion)
.Replace("{CLISdkBrandName}", Monikers.CLISdkBrandName) .Replace("{CLISdkBrandName}", Monikers.CLISdkBrandName)
.Replace("{SharedFxBrandName}", Monikers.SharedFxBrandName) .Replace("{SharedFxBrandName}", Monikers.SharedFxBrandName)
.Replace("{SharedHostBrandName}", Monikers.SharedHostBrandName) .Replace("{SharedHostBrandName}", Monikers.SharedHostBrandName)
.Replace("{HostFxrBrandName}", Monikers.HostFxrBrandName); .Replace("{HostFxrBrandName}", Monikers.HostFxrBrandName);
File.WriteAllText(distributionPath, formattedDistContents); File.WriteAllText(distributionPath, formattedDistContents);
Cmd("productbuild", Cmd("productbuild",
"--version", CLISdkNugetVersion, "--version", CLISdkNugetVersion,
"--identifier", CLISdkPkgId, "--identifier", CLISdkPkgId,
"--package-path", PkgsIntermediateDir, "--package-path", PkgsIntermediateDir,
"--resources", resourcePath, "--resources", resourcePath,
"--distribution", distributionPath, "--distribution", distributionPath,
outFilePath) outFilePath)
.Execute() .Execute()
.EnsureSuccessful(); .EnsureSuccessful();
}
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.OSX)]
public static BuildTargetResult GenerateCLISdkPkg(BuildTargetContext c) public static BuildTargetResult GenerateCLISdkPkg(BuildTargetContext c)
{ {
string outFilePath = Path.Combine(PkgsIntermediateDir, CLISdkComponentId + ".pkg"); if (CurrentPlatform.IsPlatform(BuildPlatform.OSX))
string installLocation = "/usr/local/share/dotnet"; {
string scriptsLocation = Path.Combine(Dirs.RepoRoot, "packaging", "osx", "clisdk", "scripts"); string outFilePath = Path.Combine(PkgsIntermediateDir, CLISdkComponentId + ".pkg");
string installLocation = "/usr/local/share/dotnet";
string scriptsLocation = Path.Combine(Dirs.RepoRoot, "packaging", "osx", "clisdk", "scripts");
Cmd("pkgbuild", Cmd("pkgbuild",
"--root", c.BuildContext.Get<string>("CLISDKRoot"), "--root", c.BuildContext.Get<string>("CLISDKRoot"),
"--identifier", CLISdkComponentId, "--identifier", CLISdkComponentId,
"--version", CLISdkNugetVersion, "--version", CLISdkNugetVersion,
"--install-location", installLocation, "--install-location", installLocation,
"--scripts", scriptsLocation, "--scripts", scriptsLocation,
outFilePath) outFilePath)
.Execute() .Execute()
.EnsureSuccessful(); .EnsureSuccessful();
}
return c.Success(); return c.Success();
} }

340
build_projects/dotnet-cli-build/PrepareTargets.cs
View file

@ -13,35 +13,71 @@ using static Microsoft.DotNet.Cli.Build.Framework.BuildHelpers;
using static Microsoft.DotNet.Cli.Build.FS; using static Microsoft.DotNet.Cli.Build.FS;
using static Microsoft.DotNet.Cli.Build.Utils; using static Microsoft.DotNet.Cli.Build.Utils;
using System.IO.Compression; using System.IO.Compression;
using Microsoft.Build.Utilities;
namespace Microsoft.DotNet.Cli.Build namespace Microsoft.DotNet.Cli.Build
{ {
public class PrepareTargets public class PrepareTargets : Task
{ {
[Target(nameof(Init), nameof(DownloadHostAndSharedFxArtifacts), nameof(RestorePackages), nameof(ZipTemplates))] public override bool Execute()
public static BuildTargetResult Prepare(BuildTargetContext c) => c.Success(); {
BuildContext context = new BuildSetup("MSBuild").UseAllTargetsFromAssembly<PrepareTargets>().CreateBuildContext();
BuildTargetContext c = new BuildTargetContext(context, null, null);
[Target(nameof(CheckPrereqCmakePresent), nameof(CheckPlatformDependencies))] return Prepare(c).Success;
public static BuildTargetResult CheckPrereqs(BuildTargetContext c) => c.Success(); }
[Target(nameof(CheckCoreclrPlatformDependencies), nameof(CheckInstallerBuildPlatformDependencies))] [Target]
public static BuildTargetResult CheckPlatformDependencies(BuildTargetContext c) => c.Success(); public static BuildTargetResult Prepare(BuildTargetContext c)
{
Init(c);
DownloadHostAndSharedFxArtifacts(c);
RestorePackages(c);
ZipTemplates(c);
[Target(nameof(CheckUbuntuCoreclrAndCoreFxDependencies), nameof(CheckCentOSCoreclrAndCoreFxDependencies))] return c.Success();
public static BuildTargetResult CheckCoreclrPlatformDependencies(BuildTargetContext c) => c.Success(); }
[Target(nameof(CheckUbuntuDebianPackageBuildDependencies))] public static BuildTargetResult CheckPrereqs(BuildTargetContext c)
public static BuildTargetResult CheckInstallerBuildPlatformDependencies(BuildTargetContext c) => c.Success(); {
CheckPrereqCmakePresent(c);
CheckPlatformDependencies(c);
return c.Success();
}
public static BuildTargetResult CheckPlatformDependencies(BuildTargetContext c)
{
CheckCoreclrPlatformDependencies(c);
CheckInstallerBuildPlatformDependencies(c);
return c.Success();
}
public static BuildTargetResult CheckCoreclrPlatformDependencies(BuildTargetContext c)
{
CheckUbuntuCoreclrAndCoreFxDependencies(c);
CheckCentOSCoreclrAndCoreFxDependencies(c);
return c.Success();
}
public static BuildTargetResult CheckInstallerBuildPlatformDependencies(BuildTargetContext c)
{
CheckUbuntuDebianPackageBuildDependencies(c);
return c.Success();
}
// All major targets will depend on this in order to ensure variables are set up right if they are run independently // All major targets will depend on this in order to ensure variables are set up right if they are run independently
[Target(
nameof(GenerateVersions),
nameof(CheckPrereqs),
nameof(LocateStage0),
nameof(ExpectedBuildArtifacts),
nameof(SetTelemetryProfile))]
public static BuildTargetResult Init(BuildTargetContext c) public static BuildTargetResult Init(BuildTargetContext c)
{ {
GenerateVersions(c);
CheckPrereqs(c);
LocateStage0(c);
ExpectedBuildArtifacts(c);
SetTelemetryProfile(c);
var configEnv = Environment.GetEnvironmentVariable("CONFIGURATION"); var configEnv = Environment.GetEnvironmentVariable("CONFIGURATION");
if (string.IsNullOrEmpty(configEnv)) if (string.IsNullOrEmpty(configEnv))
@ -60,7 +96,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult GenerateVersions(BuildTargetContext c) public static BuildTargetResult GenerateVersions(BuildTargetContext c)
{ {
var commitCount = GitUtils.GetCommitCount(); var commitCount = GitUtils.GetCommitCount();
@ -86,7 +121,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult ZipTemplates(BuildTargetContext c) public static BuildTargetResult ZipTemplates(BuildTargetContext c)
{ {
var templateDirectories = Directory.GetDirectories( var templateDirectories = Directory.GetDirectories(
@ -106,7 +140,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult LocateStage0(BuildTargetContext c) public static BuildTargetResult LocateStage0(BuildTargetContext c)
{ {
// We should have been run in the repo root, so locate the stage 0 relative to current directory // We should have been run in the repo root, so locate the stage 0 relative to current directory
@ -131,7 +164,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult ExpectedBuildArtifacts(BuildTargetContext c) public static BuildTargetResult ExpectedBuildArtifacts(BuildTargetContext c)
{ {
var config = Environment.GetEnvironmentVariable("CONFIGURATION"); var config = Environment.GetEnvironmentVariable("CONFIGURATION");
@ -158,13 +190,15 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target( public static BuildTargetResult DownloadHostAndSharedFxArtifacts(BuildTargetContext c)
nameof(ExpectedBuildArtifacts), {
nameof(DownloadHostAndSharedFxArchives), ExpectedBuildArtifacts(c);
nameof(DownloadHostAndSharedFxInstallers))] DownloadHostAndSharedFxArchives(c);
public static BuildTargetResult DownloadHostAndSharedFxArtifacts(BuildTargetContext c) => c.Success(); DownloadHostAndSharedFxInstallers(c);
return c.Success();
}
[Target]
public static BuildTargetResult DownloadHostAndSharedFxArchives(BuildTargetContext c) public static BuildTargetResult DownloadHostAndSharedFxArchives(BuildTargetContext c)
{ {
var sharedFrameworkVersion = CliDependencyVersions.SharedFrameworkVersion; var sharedFrameworkVersion = CliDependencyVersions.SharedFrameworkVersion;
@ -205,75 +239,75 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Windows, BuildPlatform.OSX, BuildPlatform.Ubuntu)]
public static BuildTargetResult DownloadHostAndSharedFxInstallers(BuildTargetContext c) public static BuildTargetResult DownloadHostAndSharedFxInstallers(BuildTargetContext c)
{ {
var sharedFrameworkVersion = CliDependencyVersions.SharedFrameworkVersion; if (CurrentPlatform.IsAnyPlatform(BuildPlatform.Windows, BuildPlatform.OSX, BuildPlatform.Ubuntu))
var hostVersion = CliDependencyVersions.SharedHostVersion;
var hostFxrVersion = CliDependencyVersions.HostFxrVersion;
var sharedFrameworkChannel = CliDependencyVersions.SharedFrameworkChannel;
var sharedHostChannel = CliDependencyVersions.SharedHostChannel;
var hostFxrChannel = CliDependencyVersions.HostFxrChannel;
var sharedFrameworkInstallerDownloadFile = Path.Combine(CliDirs.CoreSetupDownload, "sharedFrameworkInstaller");
var sharedHostInstallerDownloadFile = Path.Combine(CliDirs.CoreSetupDownload, "sharedHostInstaller");
var hostFxrInstallerDownloadFile = Path.Combine(CliDirs.CoreSetupDownload, "hostFxrInstaller");
Mkdirp(Path.GetDirectoryName(sharedFrameworkInstallerDownloadFile));
Mkdirp(Path.GetDirectoryName(sharedHostInstallerDownloadFile));
Mkdirp(Path.GetDirectoryName(hostFxrInstallerDownloadFile));
if (!File.Exists(sharedFrameworkInstallerDownloadFile))
{ {
var sharedFrameworkInstallerDestinationFile = c.BuildContext.Get<string>("SharedFrameworkInstallerFile"); var sharedFrameworkVersion = CliDependencyVersions.SharedFrameworkVersion;
Mkdirp(Path.GetDirectoryName(sharedFrameworkInstallerDestinationFile)); var hostVersion = CliDependencyVersions.SharedHostVersion;
var hostFxrVersion = CliDependencyVersions.HostFxrVersion;
AzurePublisher.DownloadFile( var sharedFrameworkChannel = CliDependencyVersions.SharedFrameworkChannel;
CalculateInstallerBlob( var sharedHostChannel = CliDependencyVersions.SharedHostChannel;
sharedFrameworkInstallerDestinationFile, var hostFxrChannel = CliDependencyVersions.HostFxrChannel;
sharedFrameworkChannel,
sharedFrameworkVersion),
sharedFrameworkInstallerDownloadFile).Wait();
File.Copy(sharedFrameworkInstallerDownloadFile, sharedFrameworkInstallerDestinationFile, true); var sharedFrameworkInstallerDownloadFile = Path.Combine(CliDirs.CoreSetupDownload, "sharedFrameworkInstaller");
} var sharedHostInstallerDownloadFile = Path.Combine(CliDirs.CoreSetupDownload, "sharedHostInstaller");
var hostFxrInstallerDownloadFile = Path.Combine(CliDirs.CoreSetupDownload, "hostFxrInstaller");
if (!File.Exists(sharedHostInstallerDownloadFile)) Mkdirp(Path.GetDirectoryName(sharedFrameworkInstallerDownloadFile));
{ Mkdirp(Path.GetDirectoryName(sharedHostInstallerDownloadFile));
var sharedHostInstallerDestinationFile = c.BuildContext.Get<string>("SharedHostInstallerFile"); Mkdirp(Path.GetDirectoryName(hostFxrInstallerDownloadFile));
Mkdirp(Path.GetDirectoryName(sharedHostInstallerDestinationFile));
AzurePublisher.DownloadFile( if (!File.Exists(sharedFrameworkInstallerDownloadFile))
CalculateInstallerBlob( {
sharedHostInstallerDestinationFile, var sharedFrameworkInstallerDestinationFile = c.BuildContext.Get<string>("SharedFrameworkInstallerFile");
sharedHostChannel, Mkdirp(Path.GetDirectoryName(sharedFrameworkInstallerDestinationFile));
hostVersion),
sharedHostInstallerDownloadFile).Wait();
File.Copy(sharedHostInstallerDownloadFile, sharedHostInstallerDestinationFile, true); AzurePublisher.DownloadFile(
} CalculateInstallerBlob(
sharedFrameworkInstallerDestinationFile,
sharedFrameworkChannel,
sharedFrameworkVersion),
sharedFrameworkInstallerDownloadFile).Wait();
if (!File.Exists(hostFxrInstallerDownloadFile)) File.Copy(sharedFrameworkInstallerDownloadFile, sharedFrameworkInstallerDestinationFile, true);
{ }
var hostFxrInstallerDestinationFile = c.BuildContext.Get<string>("HostFxrInstallerFile");
Mkdirp(Path.GetDirectoryName(hostFxrInstallerDestinationFile));
AzurePublisher.DownloadFile( if (!File.Exists(sharedHostInstallerDownloadFile))
CalculateInstallerBlob( {
hostFxrInstallerDestinationFile, var sharedHostInstallerDestinationFile = c.BuildContext.Get<string>("SharedHostInstallerFile");
hostFxrChannel, Mkdirp(Path.GetDirectoryName(sharedHostInstallerDestinationFile));
hostFxrVersion),
hostFxrInstallerDownloadFile).Wait();
File.Copy(hostFxrInstallerDownloadFile, hostFxrInstallerDestinationFile, true); AzurePublisher.DownloadFile(
CalculateInstallerBlob(
sharedHostInstallerDestinationFile,
sharedHostChannel,
hostVersion),
sharedHostInstallerDownloadFile).Wait();
File.Copy(sharedHostInstallerDownloadFile, sharedHostInstallerDestinationFile, true);
}
if (!File.Exists(hostFxrInstallerDownloadFile))
{
var hostFxrInstallerDestinationFile = c.BuildContext.Get<string>("HostFxrInstallerFile");
Mkdirp(Path.GetDirectoryName(hostFxrInstallerDestinationFile));
AzurePublisher.DownloadFile(
CalculateInstallerBlob(
hostFxrInstallerDestinationFile,
hostFxrChannel,
hostFxrVersion),
hostFxrInstallerDownloadFile).Wait();
File.Copy(hostFxrInstallerDownloadFile, hostFxrInstallerDestinationFile, true);
}
} }
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CheckPackageCache(BuildTargetContext c) public static BuildTargetResult CheckPackageCache(BuildTargetContext c)
{ {
var ciBuild = string.Equals(Environment.GetEnvironmentVariable("CI_BUILD"), "1", StringComparison.Ordinal); var ciBuild = string.Equals(Environment.GetEnvironmentVariable("CI_BUILD"), "1", StringComparison.Ordinal);
@ -327,9 +361,10 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target(nameof(CheckPackageCache))]
public static BuildTargetResult RestorePackages(BuildTargetContext c) public static BuildTargetResult RestorePackages(BuildTargetContext c)
{ {
CheckPackageCache(c);
var dotnet = DotNetCli.Stage0; var dotnet = DotNetCli.Stage0;
dotnet.Restore("--verbosity", "verbose", "--disable-parallel") dotnet.Restore("--verbosity", "verbose", "--disable-parallel")
@ -344,92 +379,99 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Ubuntu, "14.04")]
public static BuildTargetResult CheckUbuntuDebianPackageBuildDependencies(BuildTargetContext c) public static BuildTargetResult CheckUbuntuDebianPackageBuildDependencies(BuildTargetContext c)
{ {
if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu, "14.04"))
var messageBuilder = new StringBuilder();
var aptDependencyUtility = new AptDependencyUtility();
foreach (var package in PackageDependencies.DebianPackageBuildDependencies)
{ {
if (!AptDependencyUtility.PackageIsInstalled(package)) var messageBuilder = new StringBuilder();
var aptDependencyUtility = new AptDependencyUtility();
foreach (var package in PackageDependencies.DebianPackageBuildDependencies)
{ {
messageBuilder.Append($"Error: Debian package build dependency {package} missing."); if (!AptDependencyUtility.PackageIsInstalled(package))
messageBuilder.Append(Environment.NewLine); {
messageBuilder.Append($"-> install with apt-get install {package}"); messageBuilder.Append($"Error: Debian package build dependency {package} missing.");
messageBuilder.Append(Environment.NewLine); messageBuilder.Append(Environment.NewLine);
messageBuilder.Append($"-> install with apt-get install {package}");
messageBuilder.Append(Environment.NewLine);
}
}
if (messageBuilder.Length == 0)
{
return c.Success();
}
else
{
return c.Failed(messageBuilder.ToString());
} }
} }
if (messageBuilder.Length == 0) return c.Success();
{
return c.Success();
}
else
{
return c.Failed(messageBuilder.ToString());
}
} }
[Target]
[BuildPlatforms(BuildPlatform.Ubuntu, "14.04")]
public static BuildTargetResult CheckUbuntuCoreclrAndCoreFxDependencies(BuildTargetContext c) public static BuildTargetResult CheckUbuntuCoreclrAndCoreFxDependencies(BuildTargetContext c)
{ {
var errorMessageBuilder = new StringBuilder(); if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu, "14.04"))
var stage0 = DotNetCli.Stage0.BinPath;
foreach (var package in PackageDependencies.UbuntuCoreclrAndCoreFxDependencies)
{ {
if (!AptDependencyUtility.PackageIsInstalled(package)) var errorMessageBuilder = new StringBuilder();
var stage0 = DotNetCli.Stage0.BinPath;
foreach (var package in PackageDependencies.UbuntuCoreclrAndCoreFxDependencies)
{ {
errorMessageBuilder.Append($"Error: Coreclr package dependency {package} missing."); if (!AptDependencyUtility.PackageIsInstalled(package))
errorMessageBuilder.Append(Environment.NewLine); {
errorMessageBuilder.Append($"-> install with apt-get install {package}"); errorMessageBuilder.Append($"Error: Coreclr package dependency {package} missing.");
errorMessageBuilder.Append(Environment.NewLine); errorMessageBuilder.Append(Environment.NewLine);
errorMessageBuilder.Append($"-> install with apt-get install {package}");
errorMessageBuilder.Append(Environment.NewLine);
}
}
if (errorMessageBuilder.Length == 0)
{
return c.Success();
}
else
{
return c.Failed(errorMessageBuilder.ToString());
} }
} }
if (errorMessageBuilder.Length == 0) return c.Success();
{
return c.Success();
}
else
{
return c.Failed(errorMessageBuilder.ToString());
}
} }
[Target]
[BuildPlatforms(BuildPlatform.CentOS)]
public static BuildTargetResult CheckCentOSCoreclrAndCoreFxDependencies(BuildTargetContext c) public static BuildTargetResult CheckCentOSCoreclrAndCoreFxDependencies(BuildTargetContext c)
{ {
var errorMessageBuilder = new StringBuilder(); if (CurrentPlatform.IsPlatform(BuildPlatform.CentOS))
foreach (var package in PackageDependencies.CentosCoreclrAndCoreFxDependencies)
{ {
if (!YumDependencyUtility.PackageIsInstalled(package)) var errorMessageBuilder = new StringBuilder();
foreach (var package in PackageDependencies.CentosCoreclrAndCoreFxDependencies)
{ {
errorMessageBuilder.Append($"Error: Coreclr package dependency {package} missing."); if (!YumDependencyUtility.PackageIsInstalled(package))
errorMessageBuilder.Append(Environment.NewLine); {
errorMessageBuilder.Append($"-> install with yum install {package}"); errorMessageBuilder.Append($"Error: Coreclr package dependency {package} missing.");
errorMessageBuilder.Append(Environment.NewLine); errorMessageBuilder.Append(Environment.NewLine);
errorMessageBuilder.Append($"-> install with yum install {package}");
errorMessageBuilder.Append(Environment.NewLine);
}
}
if (errorMessageBuilder.Length == 0)
{
return c.Success();
}
else
{
return c.Failed(errorMessageBuilder.ToString());
} }
} }
if (errorMessageBuilder.Length == 0) return c.Success();
{
return c.Success();
}
else
{
return c.Failed(errorMessageBuilder.ToString());
}
} }
[Target]
public static BuildTargetResult CheckPrereqCmakePresent(BuildTargetContext c) public static BuildTargetResult CheckPrereqCmakePresent(BuildTargetContext c)
{ {
try try
@ -461,7 +503,6 @@ cmake is required to build the native host 'corehost'";
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult SetTelemetryProfile(BuildTargetContext c) public static BuildTargetResult SetTelemetryProfile(BuildTargetContext c)
{ {
var gitResult = Cmd("git", "rev-parse", "HEAD") var gitResult = Cmd("git", "rev-parse", "HEAD")
@ -476,23 +517,6 @@ cmake is required to build the native host 'corehost'";
return c.Success(); return c.Success();
} }
private static string GetVersionFromProjectJson(string pathToProjectJson)
{
Regex r = new Regex($"\"{Regex.Escape(Monikers.SharedFrameworkName)}\"\\s*:\\s*\"(?'version'[^\"]*)\"");
foreach (var line in File.ReadAllLines(pathToProjectJson))
{
var m = r.Match(line);
if (m.Success)
{
return m.Groups["version"].Value;
}
}
throw new InvalidOperationException("Unable to match the version name from " + pathToProjectJson);
}
private static IDictionary<string, string> ReadBranchInfo(BuildTargetContext c, string path) private static IDictionary<string, string> ReadBranchInfo(BuildTargetContext c, string path)
{ {
var lines = File.ReadAllLines(path); var lines = File.ReadAllLines(path);

135
build_projects/dotnet-cli-build/PublishTargets.cs
View file

@ -4,10 +4,11 @@ using System.IO;
using System.Linq; using System.Linq;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using Microsoft.DotNet.Cli.Build.Framework; using Microsoft.DotNet.Cli.Build.Framework;
using Microsoft.Build.Utilities;
namespace Microsoft.DotNet.Cli.Build namespace Microsoft.DotNet.Cli.Build
{ {
public static class PublishTargets public class PublishTargets : Task
{ {
private static AzurePublisher AzurePublisherTool { get; set; } private static AzurePublisher AzurePublisherTool { get; set; }
@ -21,7 +22,14 @@ namespace Microsoft.DotNet.Cli.Build
private static string SharedFrameworkNugetVersion { get; set; } private static string SharedFrameworkNugetVersion { get; set; }
[Target] public override bool Execute()
{
BuildContext context = new BuildSetup("MSBuild").UseAllTargetsFromAssembly<PublishTargets>().CreateBuildContext();
BuildTargetContext c = new BuildTargetContext(context, null, null);
return Publish(c).Success;
}
public static BuildTargetResult InitPublish(BuildTargetContext c) public static BuildTargetResult InitPublish(BuildTargetContext c)
{ {
AzurePublisherTool = new AzurePublisher(); AzurePublisherTool = new AzurePublisher();
@ -35,18 +43,21 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target( [Target]
nameof(PrepareTargets.Init),
nameof(PublishTargets.InitPublish),
nameof(PublishTargets.PublishArtifacts),
nameof(PublishTargets.FinalizeBuild))]
[Environment("PUBLISH_TO_AZURE_BLOB", "1", "true")] // This is set by CI systems
public static BuildTargetResult Publish(BuildTargetContext c) public static BuildTargetResult Publish(BuildTargetContext c)
{ {
if (EnvVars.GetBool("PUBLISH_TO_AZURE_BLOB")) // This is set by CI systems
{
PrepareTargets.Init(c);
InitPublish(c);
PublishArtifacts(c);
FinalizeBuild(c);
}
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult FinalizeBuild(BuildTargetContext c) public static BuildTargetResult FinalizeBuild(BuildTargetContext c)
{ {
if (CheckIfAllBuildsHavePublished()) if (CheckIfAllBuildsHavePublished())
@ -148,33 +159,43 @@ namespace Microsoft.DotNet.Cli.Build
return badges.Values.All(v => v); return badges.Values.All(v => v);
} }
[Target( public static BuildTargetResult PublishArtifacts(BuildTargetContext c)
nameof(PublishTargets.PublishInstallerFilesToAzure),
nameof(PublishTargets.PublishArchivesToAzure),
nameof(PublishTargets.PublishDebFilesToDebianRepo),
nameof(PublishTargets.PublishCliVersionBadge))]
public static BuildTargetResult PublishArtifacts(BuildTargetContext c) => c.Success();
[Target(
nameof(PublishTargets.PublishSdkInstallerFileToAzure),
nameof(PublishTargets.PublishCombinedFrameworkSDKHostInstallerFileToAzure))]
public static BuildTargetResult PublishInstallerFilesToAzure(BuildTargetContext c) => c.Success();
[Target(
nameof(PublishTargets.PublishCombinedHostFrameworkSdkArchiveToAzure),
nameof(PublishTargets.PublishCombinedFrameworkSDKArchiveToAzure),
nameof(PublishTargets.PublishSDKSymbolsArchiveToAzure))]
public static BuildTargetResult PublishArchivesToAzure(BuildTargetContext c) => c.Success();
[Target(
nameof(PublishSdkDebToDebianRepo))]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult PublishDebFilesToDebianRepo(BuildTargetContext c)
{ {
PublishInstallerFilesToAzure(c);
PublishArchivesToAzure(c);
PublishDebFilesToDebianRepo(c);
PublishCliVersionBadge(c);
return c.Success();
}
public static BuildTargetResult PublishInstallerFilesToAzure(BuildTargetContext c)
{
PublishSdkInstallerFileToAzure(c);
PublishCombinedFrameworkSDKHostInstallerFileToAzure(c);
return c.Success();
}
public static BuildTargetResult PublishArchivesToAzure(BuildTargetContext c)
{
PublishCombinedHostFrameworkSdkArchiveToAzure(c);
PublishCombinedFrameworkSDKArchiveToAzure(c);
PublishSDKSymbolsArchiveToAzure(c);
return c.Success();
}
public static BuildTargetResult PublishDebFilesToDebianRepo(BuildTargetContext c)
{
if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
{
PublishSdkDebToDebianRepo(c);
}
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult PublishCliVersionBadge(BuildTargetContext c) public static BuildTargetResult PublishCliVersionBadge(BuildTargetContext c)
{ {
var versionBadge = c.BuildContext.Get<string>("VersionBadge"); var versionBadge = c.BuildContext.Get<string>("VersionBadge");
@ -183,37 +204,39 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult PublishSdkInstallerFileToAzure(BuildTargetContext c) public static BuildTargetResult PublishSdkInstallerFileToAzure(BuildTargetContext c)
{ {
var installerFile = c.BuildContext.Get<string>("SdkInstallerFile"); if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
UploadFile(installerFile); {
var installerFile = c.BuildContext.Get<string>("SdkInstallerFile");
UploadFile(installerFile);
}
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Windows, BuildPlatform.OSX)]
public static BuildTargetResult PublishCombinedFrameworkSDKHostInstallerFileToAzure(BuildTargetContext c) public static BuildTargetResult PublishCombinedFrameworkSDKHostInstallerFileToAzure(BuildTargetContext c)
{ {
var installerFile = c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile"); if (CurrentPlatform.IsAnyPlatform(BuildPlatform.Windows, BuildPlatform.OSX))
UploadFile(installerFile); {
var installerFile = c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile");
UploadFile(installerFile);
}
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult PublishCombinedFrameworkSDKArchiveToAzure(BuildTargetContext c) public static BuildTargetResult PublishCombinedFrameworkSDKArchiveToAzure(BuildTargetContext c)
{ {
var archiveFile = c.BuildContext.Get<string>("CombinedFrameworkSDKCompressedFile"); if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
UploadFile(archiveFile); {
var archiveFile = c.BuildContext.Get<string>("CombinedFrameworkSDKCompressedFile");
UploadFile(archiveFile);
}
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult PublishCombinedHostFrameworkSdkArchiveToAzure(BuildTargetContext c) public static BuildTargetResult PublishCombinedHostFrameworkSdkArchiveToAzure(BuildTargetContext c)
{ {
var archiveFile = c.BuildContext.Get<string>("CombinedFrameworkSDKHostCompressedFile"); var archiveFile = c.BuildContext.Get<string>("CombinedFrameworkSDKHostCompressedFile");
@ -222,7 +245,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult PublishSDKSymbolsArchiveToAzure(BuildTargetContext c) public static BuildTargetResult PublishSDKSymbolsArchiveToAzure(BuildTargetContext c)
{ {
var archiveFile = c.BuildContext.Get<string>("SdkSymbolsCompressedFile"); var archiveFile = c.BuildContext.Get<string>("SdkSymbolsCompressedFile");
@ -231,20 +253,21 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Ubuntu)]
public static BuildTargetResult PublishSdkDebToDebianRepo(BuildTargetContext c) public static BuildTargetResult PublishSdkDebToDebianRepo(BuildTargetContext c)
{ {
var version = CliNuGetVersion; if (CurrentPlatform.IsPlatform(BuildPlatform.Ubuntu))
{
var version = CliNuGetVersion;
var packageName = CliMonikers.GetSdkDebianPackageName(c); var packageName = CliMonikers.GetSdkDebianPackageName(c);
var installerFile = c.BuildContext.Get<string>("SdkInstallerFile"); var installerFile = c.BuildContext.Get<string>("SdkInstallerFile");
var uploadUrl = AzurePublisher.CalculateFullUrlForFile(installerFile, AzurePublisher.Product.Sdk, version); var uploadUrl = AzurePublisher.CalculateFullUrlForFile(installerFile, AzurePublisher.Product.Sdk, version);
DebRepoPublisherTool.PublishDebFileToDebianRepo( DebRepoPublisherTool.PublishDebFileToDebianRepo(
packageName, packageName,
version, version,
uploadUrl); uploadUrl);
}
return c.Success(); return c.Success();
} }

118
build_projects/dotnet-cli-build/TestTargets.cs
View file

@ -8,10 +8,11 @@ using Microsoft.DotNet.Cli.Build.Framework;
using static Microsoft.DotNet.Cli.Build.FS; using static Microsoft.DotNet.Cli.Build.FS;
using static Microsoft.DotNet.Cli.Build.Framework.BuildHelpers; using static Microsoft.DotNet.Cli.Build.Framework.BuildHelpers;
using static Microsoft.DotNet.Cli.Build.Utils; using static Microsoft.DotNet.Cli.Build.Utils;
using Microsoft.Build.Utilities;
namespace Microsoft.DotNet.Cli.Build namespace Microsoft.DotNet.Cli.Build
{ {
public class TestTargets public class TestTargets : Task
{ {
private static string s_testPackageBuildVersionSuffix = "<buildversion>"; private static string s_testPackageBuildVersionSuffix = "<buildversion>";
@ -57,28 +58,53 @@ namespace Microsoft.DotNet.Cli.Build
new { Path = "AppWithDirectDependencyDesktopAndPortable", Skip = new Func<bool>(() => !CurrentPlatform.IsWindows) } new { Path = "AppWithDirectDependencyDesktopAndPortable", Skip = new Func<bool>(() => !CurrentPlatform.IsWindows) }
}; };
[Target( public override bool Execute()
nameof(PrepareTargets.Init), {
nameof(SetupTests), BuildContext context = new BuildSetup("MSBuild").UseAllTargetsFromAssembly<TestTargets>().CreateBuildContext();
nameof(RestoreTests), BuildTargetContext c = new BuildTargetContext(context, null, null);
nameof(BuildTests),
nameof(RunTests),
nameof(ValidateDependencies))]
public static BuildTargetResult Test(BuildTargetContext c) => c.Success();
[Target(nameof(SetupTestPackages), nameof(SetupTestProjects))] return Test(c).Success;
public static BuildTargetResult SetupTests(BuildTargetContext c) => c.Success(); }
[Target(nameof(RestoreTestAssetPackages), nameof(BuildTestAssetPackages))]
public static BuildTargetResult SetupTestPackages(BuildTargetContext c) => c.Success();
[Target(nameof(RestoreTestAssetProjects),
nameof(RestoreDesktopTestAssetProjects),
nameof(BuildTestAssetProjects),
nameof(BuildDesktopTestAssetProjects))]
public static BuildTargetResult SetupTestProjects(BuildTargetContext c) => c.Success();
[Target] [Target]
public static BuildTargetResult Test(BuildTargetContext c)
{
PrepareTargets.Init(c);
SetupTests(c);
RestoreTests(c);
BuildTests(c);
RunTests(c);
ValidateDependencies(c);
return c.Success();
}
public static BuildTargetResult SetupTests(BuildTargetContext c)
{
SetupTestPackages(c);
SetupTestProjects(c);
return c.Success();
}
public static BuildTargetResult SetupTestPackages(BuildTargetContext c)
{
RestoreTestAssetPackages(c);
BuildTestAssetPackages(c);
return c.Success();
}
public static BuildTargetResult SetupTestProjects(BuildTargetContext c)
{
RestoreTestAssetProjects(c);
RestoreDesktopTestAssetProjects(c);
BuildTestAssetProjects(c);
BuildDesktopTestAssetProjects(c);
return c.Success();
}
public static BuildTargetResult RestoreTestAssetPackages(BuildTargetContext c) public static BuildTargetResult RestoreTestAssetPackages(BuildTargetContext c)
{ {
CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src"));
@ -95,7 +121,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult RestoreTestAssetProjects(BuildTargetContext c) public static BuildTargetResult RestoreTestAssetProjects(BuildTargetContext c)
{ {
CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src"));
@ -127,24 +152,27 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult RestoreDesktopTestAssetProjects(BuildTargetContext c) public static BuildTargetResult RestoreDesktopTestAssetProjects(BuildTargetContext c)
{ {
var dotnet = DotNetCli.Stage2; if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
{
var dotnet = DotNetCli.Stage2;
dotnet.Restore("--verbosity", "verbose", dotnet.Restore("--verbosity", "verbose",
"--infer-runtimes", "--infer-runtimes",
"--fallbacksource", Dirs.TestPackages) "--fallbacksource", Dirs.TestPackages)
.WorkingDirectory(Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "DesktopTestProjects")) .WorkingDirectory(Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "DesktopTestProjects"))
.Execute().EnsureSuccessful(); .Execute().EnsureSuccessful();
}
return c.Success(); return c.Success();
} }
[Target(nameof(CleanTestPackages), nameof(CleanProductPackages))]
public static BuildTargetResult BuildTestAssetPackages(BuildTargetContext c) public static BuildTargetResult BuildTestAssetPackages(BuildTargetContext c)
{ {
CleanTestPackages(c);
CleanProductPackages(c);
CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "TestPackages")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "TestPackages"));
var dotnet = DotNetCli.Stage2; var dotnet = DotNetCli.Stage2;
@ -209,7 +237,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CleanProductPackages(BuildTargetContext c) public static BuildTargetResult CleanProductPackages(BuildTargetContext c)
{ {
foreach (var packageName in PackageTargets.ProjectsToPack) foreach (var packageName in PackageTargets.ProjectsToPack)
@ -220,7 +247,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult CleanTestPackages(BuildTargetContext c) public static BuildTargetResult CleanTestPackages(BuildTargetContext c)
{ {
foreach (var packageProject in TestPackageProjects.Projects.Where(p => p.IsApplicable && p.Clean)) foreach (var packageProject in TestPackageProjects.Projects.Where(p => p.IsApplicable && p.Clean))
@ -234,7 +260,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult BuildTestAssetProjects(BuildTargetContext c) public static BuildTargetResult BuildTestAssetProjects(BuildTargetContext c)
{ {
var testAssetsRoot = Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "TestProjects"); var testAssetsRoot = Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "TestProjects");
@ -244,18 +269,20 @@ namespace Microsoft.DotNet.Cli.Build
return BuildTestAssets(c, testAssetsRoot, dotnet, framework); return BuildTestAssets(c, testAssetsRoot, dotnet, framework);
} }
[Target]
[BuildPlatforms(BuildPlatform.Windows)]
public static BuildTargetResult BuildDesktopTestAssetProjects(BuildTargetContext c) public static BuildTargetResult BuildDesktopTestAssetProjects(BuildTargetContext c)
{ {
var testAssetsRoot = Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "DesktopTestProjects"); if (CurrentPlatform.IsPlatform(BuildPlatform.Windows))
var dotnet = DotNetCli.Stage2; {
var framework = "net451"; var testAssetsRoot = Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "DesktopTestProjects");
var dotnet = DotNetCli.Stage2;
var framework = "net451";
return BuildTestAssets(c, testAssetsRoot, dotnet, framework); return BuildTestAssets(c, testAssetsRoot, dotnet, framework);
}
return c.Success();
} }
[Target]
public static BuildTargetResult RestoreTests(BuildTargetContext c) public static BuildTargetResult RestoreTests(BuildTargetContext c)
{ {
CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src"));
@ -270,7 +297,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult BuildTests(BuildTargetContext c) public static BuildTargetResult BuildTests(BuildTargetContext c)
{ {
var dotnet = DotNetCli.Stage2; var dotnet = DotNetCli.Stage2;
@ -288,10 +314,13 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target(nameof(RunXUnitTests))] public static BuildTargetResult RunTests(BuildTargetContext c)
public static BuildTargetResult RunTests(BuildTargetContext c) => c.Success(); {
RunXUnitTests(c);
return c.Success();
}
[Target]
public static BuildTargetResult RunXUnitTests(BuildTargetContext c) public static BuildTargetResult RunXUnitTests(BuildTargetContext c)
{ {
// Need to load up the VS Vars // Need to load up the VS Vars
@ -335,7 +364,6 @@ namespace Microsoft.DotNet.Cli.Build
return c.Success(); return c.Success();
} }
[Target]
public static BuildTargetResult ValidateDependencies(BuildTargetContext c) public static BuildTargetResult ValidateDependencies(BuildTargetContext c)
{ {
var configuration = c.BuildContext.Get<string>("Configuration"); var configuration = c.BuildContext.Get<string>("Configuration");

33
build_projects/dotnet-cli-build/build.ps1
View file

@ -8,23 +8,9 @@ param(
[string[]]$Targets=@("Default"), [string[]]$Targets=@("Default"),
[string]$Architecture="x64", [string]$Architecture="x64",
[switch]$NoPackage, [switch]$NoPackage,
[switch]$NoRun,
[switch]$Help) [switch]$Help)
function RemoveDirectory([string] $path)
{
if (Test-Path $path)
{
Remove-Item $path -Recurse -Force
}
}
function CleanNuGet()
{
RemoveDirectory($env:LocalAppData + "\NuGet\Cache")
RemoveDirectory($env:LocalAppData + "\NuGet\v3-cache")
RemoveDirectory($env:NUGET_PACKAGES)
}
if($Help) if($Help)
{ {
Write-Host "Usage: .\build.ps1 [-Configuration <CONFIGURATION>] [-Targets <TARGETS...>] [-Architecture <ARCHITECTURE>] [-NoPackage] [-Help]" Write-Host "Usage: .\build.ps1 [-Configuration <CONFIGURATION>] [-Targets <TARGETS...>] [-Architecture <ARCHITECTURE>] [-NoPackage] [-Help]"
@ -34,6 +20,7 @@ if($Help)
Write-Host " -Targets <TARGETS...> Comma separated build targets to run (Init, Compile, Publish, etc.; Default is a full build and publish)" Write-Host " -Targets <TARGETS...> Comma separated build targets to run (Init, Compile, Publish, etc.; Default is a full build and publish)"
Write-Host " -Architecture <ARCHITECTURE> Build the specified architecture (x64 or x86 (supported only on Windows), default: x64)" Write-Host " -Architecture <ARCHITECTURE> Build the specified architecture (x64 or x86 (supported only on Windows), default: x64)"
Write-Host " -NoPackage Skip packaging targets" Write-Host " -NoPackage Skip packaging targets"
Write-Host " -NoRun Skip running the build"
Write-Host " -Help Display this help message" Write-Host " -Help Display this help message"
exit 0 exit 0
} }
@ -79,9 +66,6 @@ if($LASTEXITCODE -ne 0) { throw "Failed to install stage0" }
# Put the stage0 on the path # Put the stage0 on the path
$env:PATH = "$env:DOTNET_INSTALL_DIR;$env:PATH" $env:PATH = "$env:DOTNET_INSTALL_DIR;$env:PATH"
# Ensure clean package folder and caches
CleanNuGet
# Disable first run since we want to control all package sources # Disable first run since we want to control all package sources
$env:DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 $env:DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
@ -97,8 +81,11 @@ Write-Host "Compiling Build Scripts..."
dotnet publish "$PSScriptRoot" -o "$PSScriptRoot\bin" --framework netcoreapp1.0 dotnet publish "$PSScriptRoot" -o "$PSScriptRoot\bin" --framework netcoreapp1.0
if($LASTEXITCODE -ne 0) { throw "Failed to compile build scripts" } if($LASTEXITCODE -ne 0) { throw "Failed to compile build scripts" }
# Run the builder if(!$NoRun)
Write-Host "Invoking Build Scripts..." {
Write-Host " Configuration: $env:CONFIGURATION" # Run the builder
& "$PSScriptRoot\bin\dotnet-cli-build.exe" @Targets Write-Host "Invoking Build Scripts..."
if($LASTEXITCODE -ne 0) { throw "Build failed" } Write-Host " Configuration: $env:CONFIGURATION"
& "$PSScriptRoot\bin\dotnet-cli-build.exe" @Targets
if($LASTEXITCODE -ne 0) { throw "Build failed" }
}

20
build_projects/dotnet-cli-build/build.sh
View file

@ -32,6 +32,9 @@ while [[ $# > 0 ]]; do
--nopackage) --nopackage)
export DOTNET_BUILD_SKIP_PACKAGING=1 export DOTNET_BUILD_SKIP_PACKAGING=1
;; ;;
--norun)
export DOTNET_BUILD_SKIP_RUN=1
;;
--skip-prereqs) --skip-prereqs)
# Allow CI to disable prereqs check since the CI has the pre-reqs but not ldconfig it seems # Allow CI to disable prereqs check since the CI has the pre-reqs but not ldconfig it seems
export DOTNET_INSTALL_SKIP_PREREQS=1 export DOTNET_INSTALL_SKIP_PREREQS=1
@ -44,6 +47,7 @@ while [[ $# > 0 ]]; do
echo " --targets <TARGETS...> Comma separated build targets to run (Init, Compile, Publish, etc.; Default is a full build and publish)" echo " --targets <TARGETS...> Comma separated build targets to run (Init, Compile, Publish, etc.; Default is a full build and publish)"
echo " --skip-prereqs Skip checks for pre-reqs in dotnet_install" echo " --skip-prereqs Skip checks for pre-reqs in dotnet_install"
echo " --nopackage Skip packaging targets" echo " --nopackage Skip packaging targets"
echo " --norun Skip running the build"
echo " --docker <IMAGENAME> Build in Docker using the Dockerfile located in scripts/docker/IMAGENAME" echo " --docker <IMAGENAME> Build in Docker using the Dockerfile located in scripts/docker/IMAGENAME"
echo " --help Display this help message" echo " --help Display this help message"
exit 0 exit 0
@ -100,11 +104,6 @@ then
ulimit -n 1024 ulimit -n 1024
fi fi
# Clean old NuGet packages
rm -rf "$HOME/.local/share/NuGet/Cache"
rm -rf "$HOME/.local/share/NuGet/v3-cache"
rm -rf "$NUGET_PACKAGES"
# Disable first run since we want to control all package sources # Disable first run since we want to control all package sources
export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
@ -119,10 +118,13 @@ echo "Restoring Build Script projects..."
echo "Compiling Build Scripts..." echo "Compiling Build Scripts..."
dotnet publish "$DIR" -o "$DIR/bin" --framework netcoreapp1.0 dotnet publish "$DIR" -o "$DIR/bin" --framework netcoreapp1.0
export PATH="$OLDPATH" if [-z "$DOTNET_BUILD_SKIP_RUN" ]
# Run the builder then
echo "Invoking Build Scripts..." export PATH="$OLDPATH"
echo "Configuration: $CONFIGURATION" # Run the builder
echo "Invoking Build Scripts..."
echo "Configuration: $CONFIGURATION"
fi
$DIR/bin/dotnet-cli-build ${targets[@]} $DIR/bin/dotnet-cli-build ${targets[@]}
exit $? exit $?

18
build_projects/dotnet-cli-build/project.json
View file

@ -2,7 +2,15 @@
"version": "1.0.0-*", "version": "1.0.0-*",
"description": "Build scripts for dotnet-cli", "description": "Build scripts for dotnet-cli",
"buildOptions": { "buildOptions": {
"emitEntryPoint": true "emitEntryPoint": true,
"allowUnsafe": true,
"compile": [
"../Microsoft.DotNet.Cli.Build.Framework/**/*.cs",
"../shared-build-targets-utils/**/*.cs",
"../../src/Microsoft.DotNet.InternalAbstractions/RuntimeEnvironment.cs",
"../../src/Microsoft.DotNet.InternalAbstractions/Platform.cs",
"../../src/Microsoft.DotNet.InternalAbstractions/Native/*.cs"
]
}, },
"dependencies": { "dependencies": {
"NETStandard.Library": "1.6.0", "NETStandard.Library": "1.6.0",
@ -14,12 +22,8 @@
"System.Xml.XmlSerializer": "4.0.11", "System.Xml.XmlSerializer": "4.0.11",
"WindowsAzure.Storage": "6.2.2-preview", "WindowsAzure.Storage": "6.2.2-preview",
"NuGet.CommandLine.XPlat": "3.5.0-beta2-1484", "NuGet.CommandLine.XPlat": "3.5.0-beta2-1484",
"Microsoft.DotNet.Cli.Build.Framework": { "Microsoft.Build.Framework": "0.1.0-preview-00024-160610",
"target": "project" "Microsoft.Build.Utilities.Core": "0.1.0-preview-00024-160610"
},
"shared-build-targets-utils": {
"target": "project"
}
}, },
"frameworks": { "frameworks": {
"netcoreapp1.0": { "netcoreapp1.0": {

2
build_projects/shared-build-targets-utils/Utils/EnvVars.cs
View file

@ -7,7 +7,7 @@ namespace Microsoft.DotNet.Cli.Build
{ {
public static readonly bool Verbose = GetBool("DOTNET_BUILD_VERBOSE"); public static readonly bool Verbose = GetBool("DOTNET_BUILD_VERBOSE");
private static bool GetBool(string name, bool defaultValue = false) public static bool GetBool(string name, bool defaultValue = false)
{ {
var str = Environment.GetEnvironmentVariable(name); var str = Environment.GetEnvironmentVariable(name);
if (string.IsNullOrEmpty(str)) if (string.IsNullOrEmpty(str))