public static BuildTargetResult InstallSharedFramework(BuildTargetContext c)
{
InstallPackage(c.BuildContext.Get <string>("SharedFrameworkInstallerFile"));
return(c.Success());
}
[Environment("PUBLISH_TO_AZURE_BLOB", "1", "true")] // This is set by CI systems
public static BuildTargetResult Publish(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult Test(BuildTargetContext c) => c.Success();
public static BuildTargetResult PublishArtifacts(BuildTargetContext c) => c.Success();
public static BuildTargetResult PublishArchivesToAzure(BuildTargetContext c) => c.Success();
public static BuildTargetResult SetNuGetPackagesDir(BuildTargetContext c)
{
Environment.SetEnvironmentVariable("NUGET_PACKAGES", Dirs.NuGetPackages);
return(c.Success());
}
public static BuildTargetResult CheckPrereqs(BuildTargetContext c) => c.Success();
private static BuildTargetResult CompileCliSdk(
BuildTargetContext c,
DotNetCli dotnet,
string rootOutputDirectory,
bool generateNugetPackagesArchive = false)
{
var configuration = c.BuildContext.Get <string>("Configuration");
var buildVersion = c.BuildContext.Get <BuildVersion>("BuildVersion");
var srcDir = Path.Combine(c.BuildContext.BuildDirectory, "src");
var sdkOutputDirectory = Path.Combine(rootOutputDirectory, "sdk", buildVersion.NuGetVersion);
CopySharedFramework(Dirs.SharedFrameworkPublish, rootOutputDirectory);
FS.CleanBinObj(c, srcDir);
Rmdir(sdkOutputDirectory);
Mkdirp(sdkOutputDirectory);
foreach (var project in ProjectsToPublish)
{
dotnet.Publish(
"--native-subdirectory",
"--output", sdkOutputDirectory,
"--configuration", configuration,
"--version-suffix", buildVersion.CommitCountString,
Path.Combine(srcDir, project))
.Execute()
.EnsureSuccessful();
}
FixModeFlags(sdkOutputDirectory);
string compilersProject = Path.Combine(Dirs.RepoRoot, "src", "compilers");
dotnet.Publish(compilersProject,
"--output",
sdkOutputDirectory,
"--framework",
"netcoreapp1.0")
.Execute()
.EnsureSuccessful();
var compilersDeps = Path.Combine(sdkOutputDirectory, "compilers.deps.json");
var compilersRuntimeConfig = Path.Combine(sdkOutputDirectory, "compilers.runtimeconfig.json");
var binaryToCorehostifyRelDir = Path.Combine("runtimes", "any", "native");
var binaryToCorehostifyOutDir = Path.Combine(sdkOutputDirectory, binaryToCorehostifyRelDir);
// Corehostify binaries
foreach (var binaryToCorehostify in BinariesForCoreHost)
{
try
{
// Yes, it is .exe even on Linux. This is the managed exe we're working with
File.Copy(Path.Combine(binaryToCorehostifyOutDir, $"{binaryToCorehostify}.exe"), Path.Combine(sdkOutputDirectory, $"{binaryToCorehostify}.dll"));
File.Delete(Path.Combine(binaryToCorehostifyOutDir, $"{binaryToCorehostify}.exe"));
var binaryToCoreHostifyDeps = Path.Combine(sdkOutputDirectory, binaryToCorehostify + ".deps.json");
File.Copy(compilersDeps, Path.Combine(sdkOutputDirectory, binaryToCorehostify + ".deps.json"));
File.Copy(compilersRuntimeConfig, Path.Combine(sdkOutputDirectory, binaryToCorehostify + ".runtimeconfig.json"));
PublishMutationUtilties.ChangeEntryPointLibraryName(binaryToCoreHostifyDeps, binaryToCorehostify);
foreach (var binaryToRemove in new string[] { "csc", "vbc" })
{
var assetPath = Path.Combine(binaryToCorehostifyRelDir, $"{binaryToRemove}.exe").Replace(Path.DirectorySeparatorChar, '/');
RemoveAssetFromDepsPackages(binaryToCoreHostifyDeps, "runtimeTargets", assetPath);
}
}
catch (Exception ex)
{
return(c.Failed($"Failed to corehostify '{binaryToCorehostify}': {ex.ToString()}"));
}
}
// cleanup compilers project output we don't need
PublishMutationUtilties.CleanPublishOutput(
sdkOutputDirectory,
"compilers",
deleteRuntimeConfigJson: true,
deleteDepsJson: true);
// Crossgen SDK directory
var sharedFrameworkNugetVersion = CliDependencyVersions.SharedFrameworkVersion;
var sharedFrameworkNameVersionPath = SharedFrameworkPublisher.GetSharedFrameworkPublishPath(
rootOutputDirectory,
sharedFrameworkNugetVersion);
// Copy Host to SDK Directory
File.Copy(
Path.Combine(sharedFrameworkNameVersionPath, HostArtifactNames.DotnetHostBaseName),
Path.Combine(sdkOutputDirectory, $"corehost{Constants.ExeSuffix}"),
overwrite: true);
File.Copy(
Path.Combine(sharedFrameworkNameVersionPath, HostArtifactNames.DotnetHostFxrBaseName),
Path.Combine(sdkOutputDirectory, HostArtifactNames.DotnetHostFxrBaseName),
overwrite: true);
File.Copy(
Path.Combine(sharedFrameworkNameVersionPath, HostArtifactNames.HostPolicyBaseName),
Path.Combine(sdkOutputDirectory, HostArtifactNames.HostPolicyBaseName),
overwrite: true);
CrossgenUtil.CrossgenDirectory(
sharedFrameworkNameVersionPath,
sdkOutputDirectory);
// Generate .version file
var version = buildVersion.NuGetVersion;
var content = $@"{c.BuildContext["CommitHash"]}{Environment.NewLine}{version}{Environment.NewLine}";
File.WriteAllText(Path.Combine(sdkOutputDirectory, ".version"), content);
if (generateNugetPackagesArchive)
{
GenerateNuGetPackagesArchive(c, dotnet, sdkOutputDirectory);
}
return(c.Success());
}
public static BuildTargetResult UpdateBuild(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult CheckPackageCache(BuildTargetContext c)
{
var ciBuild = string.Equals(Environment.GetEnvironmentVariable("CI_BUILD"), "1", StringComparison.Ordinal);
if (ciBuild)
{
// On CI, HOME is redirected under the repo, which gets deleted after every build.
// So make NUGET_PACKAGES outside of the repo.
var nugetPackages = Path.GetFullPath(Path.Combine(c.BuildContext.BuildDirectory, "..", ".nuget", "packages"));
Environment.SetEnvironmentVariable("NUGET_PACKAGES", nugetPackages);
Dirs.NuGetPackages = nugetPackages;
}
// Set the package cache location in NUGET_PACKAGES just to be safe
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("NUGET_PACKAGES")))
{
Environment.SetEnvironmentVariable("NUGET_PACKAGES", Dirs.NuGetPackages);
}
CleanNuGetTempCache();
// Determine cache expiration time
var cacheExpiration = 7 * 24; // cache expiration in hours
var cacheExpirationStr = Environment.GetEnvironmentVariable("NUGET_PACKAGES_CACHE_TIME_LIMIT");
if (!string.IsNullOrEmpty(cacheExpirationStr))
{
cacheExpiration = int.Parse(cacheExpirationStr);
}
if (ciBuild)
{
var cacheTimeFile = Path.Combine(Dirs.NuGetPackages, "packageCacheTime.txt");
DateTime?cacheTime = null;
try
{
// Read the cache file
if (File.Exists(cacheTimeFile))
{
var content = File.ReadAllText(cacheTimeFile);
if (!string.IsNullOrEmpty(content))
{
cacheTime = DateTime.ParseExact("O", content, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
}
}
}
catch (Exception ex)
{
c.Warn($"Error reading NuGet cache time file, leaving the cache alone");
c.Warn($"Error Detail: {ex.ToString()}");
}
if (cacheTime == null || (cacheTime.Value.AddHours(cacheExpiration) < DateTime.UtcNow))
{
// Cache has expired or the status is unknown, clear it and write the file
c.Info("Clearing NuGet cache");
Rmdir(Dirs.NuGetPackages);
Mkdirp(Dirs.NuGetPackages);
File.WriteAllText(cacheTimeFile, DateTime.UtcNow.ToString("O"));
}
}
return(c.Success());
}
public static BuildTargetResult CheckInstallerBuildPlatformDependencies(BuildTargetContext c) => c.Success();
public static BuildTargetResult DownloadHostAndSharedFxArtifacts(BuildTargetContext c) => c.Success();
public static BuildTargetResult CleanTestPackages(BuildTargetContext c)
{
Rmdir(Path.Combine(Dirs.NuGetPackages, "dotnet-hello"));
return(c.Success());
}
public static BuildTargetResult CompileCoreHost(BuildTargetContext c)
{
var hostVersion = c.BuildContext.Get <HostVersion>("HostVersion");
// Generate build files
var cmakeOut = Path.Combine(Dirs.CorehostLatest, "cmake");
Rmdir(cmakeOut);
Mkdirp(cmakeOut);
var configuration = c.BuildContext.Get <string>("Configuration");
// Run the build
string rid = DotNetCli.Stage0.GetRuntimeId();
string corehostSrcDir = Path.Combine(c.BuildContext.BuildDirectory, "src", "corehost");
string commitHash = c.BuildContext.Get <string>("CommitHash");
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// Create .rc files on Windows.
var resourceDir = GenerateVersionResource(c);
// Why does Windows directly call cmake but Linux/Mac calls "build.sh" in the corehost dir?
// See the comment in "src/corehost/build.sh" for details. It doesn't work for some reason.
var visualStudio = IsWinx86 ? "Visual Studio 14 2015" : "Visual Studio 14 2015 Win64";
var archMacro = IsWinx86 ? "-DCLI_CMAKE_PLATFORM_ARCH_I386=1" : "-DCLI_CMAKE_PLATFORM_ARCH_AMD64=1";
var ridMacro = $"-DCLI_CMAKE_RUNTIME_ID:STRING={rid}";
var arch = IsWinx86 ? "x86" : "x64";
var baseSupportedRid = $"win7-{arch}";
var cmakeHostVer = $"-DCLI_CMAKE_HOST_VER:STRING={hostVersion.LatestHostVersion.ToString()}";
var cmakeHostPolicyVer = $"-DCLI_CMAKE_HOST_POLICY_VER:STRING={hostVersion.LatestHostPolicyVersion.ToString()}";
var cmakeHostFxrVer = $"-DCLI_CMAKE_HOST_FXR_VER:STRING={hostVersion.LatestHostFxrVersion.ToString()}";
var cmakeBaseRid = $"-DCLI_CMAKE_PKG_RID:STRING={baseSupportedRid}";
var cmakeCommitHash = $"-DCLI_CMAKE_COMMIT_HASH:STRING={commitHash}";
var cmakeResourceDir = $"-DCLI_CMAKE_RESOURCE_DIR:STRING={resourceDir}";
ExecIn(cmakeOut, "cmake",
corehostSrcDir,
archMacro,
ridMacro,
cmakeHostVer,
cmakeHostFxrVer,
cmakeHostPolicyVer,
cmakeBaseRid,
cmakeCommitHash,
cmakeResourceDir,
"-G",
visualStudio);
var pf32 = RuntimeInformation.OSArchitecture == Architecture.X64 ?
Environment.GetEnvironmentVariable("ProgramFiles(x86)") :
Environment.GetEnvironmentVariable("ProgramFiles");
if (configuration.Equals("Release"))
{
// Cmake calls it "RelWithDebInfo" in the generated MSBuild
configuration = "RelWithDebInfo";
}
Exec(Path.Combine(pf32, "MSBuild", "14.0", "Bin", "MSBuild.exe"),
Path.Combine(cmakeOut, "ALL_BUILD.vcxproj"),
$"/p:Configuration={configuration}");
// Copy the output out
File.Copy(Path.Combine(cmakeOut, "cli", "exe", configuration, "dotnet.exe"), Path.Combine(Dirs.CorehostLatest, "dotnet.exe"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "exe", configuration, "dotnet.pdb"), Path.Combine(Dirs.CorehostLatest, "dotnet.pdb"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "dll", configuration, "hostpolicy.dll"), Path.Combine(Dirs.CorehostLatest, "hostpolicy.dll"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "dll", configuration, "hostpolicy.pdb"), Path.Combine(Dirs.CorehostLatest, "hostpolicy.pdb"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "fxr", configuration, "hostfxr.dll"), Path.Combine(Dirs.CorehostLatest, "hostfxr.dll"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "fxr", configuration, "hostfxr.pdb"), Path.Combine(Dirs.CorehostLatest, "hostfxr.pdb"), overwrite: true);
}
else
{
ExecIn(cmakeOut, Path.Combine(c.BuildContext.BuildDirectory, "src", "corehost", "build.sh"),
"--arch",
"x64",
"--hostver",
hostVersion.LatestHostVersion.ToString(),
"--fxrver",
hostVersion.LatestHostFxrVersion.ToString(),
"--policyver",
hostVersion.LatestHostPolicyVersion.ToString(),
"--rid",
rid,
"--commithash",
commitHash);
// Copy the output out
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "dotnet"), Path.Combine(Dirs.CorehostLatest, "dotnet"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "dll", HostArtifactNames.HostPolicyBaseName), Path.Combine(Dirs.CorehostLatest, HostArtifactNames.HostPolicyBaseName), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "fxr", HostArtifactNames.DotnetHostFxrBaseName), Path.Combine(Dirs.CorehostLatest, HostArtifactNames.DotnetHostFxrBaseName), overwrite: true);
}
return(c.Success());
}
public static BuildTargetResult GenerateDotnetSharedFxMsi(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult TestDebInstaller(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult GenerateMsis(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult CompileCoreHost(BuildTargetContext c)
{
var hostVersion = c.BuildContext.Get <HostVersion>("HostVersion");
var configuration = c.BuildContext.Get <string>("Configuration");
string platform = c.BuildContext.Get <string>("Platform");
string crossEnv = c.BuildContext.Get <string>("Cross");
bool linkPortable = c.BuildContext.Get <bool>("LinkPortable");
// Generate build files
var cmakeOut = Path.Combine(Dirs.CorehostLatest, "cmake");
Rmdir(cmakeOut);
Mkdirp(cmakeOut);
// Run the build
string corehostSrcDir = Path.Combine(c.BuildContext.BuildDirectory, "src", "corehost");
string commitHash = c.BuildContext.Get <string>("CommitHash");
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// Create .rc files on Windows.
var resourceDir = GenerateVersionResource(c);
if (configuration.Equals("Release"))
{
// Cmake calls it "RelWithDebInfo" in the generated MSBuild
configuration = "RelWithDebInfo";
}
// Why does Windows directly call cmake but Linux/Mac calls "build.sh" in the corehost dir?
// See the comment in "src/corehost/build.sh" for details. It doesn't work for some reason.
List <string> cmakeArgList = new List <string>();
string cmakeBaseRid, visualStudio, archMacro, arch;
string cmakeHostVer = $"-DCLI_CMAKE_HOST_VER:STRING={hostVersion.LatestHostVersion.ToString()}";
string cmakeAppHostVer = $"-DCLI_CMAKE_APPHOST_VER:STRING={hostVersion.LatestAppHostVersion.ToString()}";
string cmakeHostPolicyVer = $"-DCLI_CMAKE_HOST_POLICY_VER:STRING={hostVersion.LatestHostPolicyVersion.ToString()}";
string cmakeHostFxrVer = $"-DCLI_CMAKE_HOST_FXR_VER:STRING={hostVersion.LatestHostFxrVersion.ToString()}";
string cmakeCommitHash = $"-DCLI_CMAKE_COMMIT_HASH:STRING={commitHash}";
string cmakeResourceDir = $"-DCLI_CMAKE_RESOURCE_DIR:STRING={resourceDir}";
switch (platform.ToLower())
{
case "x86":
cmakeBaseRid = "-DCLI_CMAKE_PKG_RID:STRING=win7-x86";
visualStudio = "Visual Studio 14 2015";
archMacro = "-DCLI_CMAKE_PLATFORM_ARCH_I386=1";
arch = "x86";
break;
case "arm":
cmakeBaseRid = "-DCLI_CMAKE_PKG_RID:STRING=win8-arm";
visualStudio = "Visual Studio 14 2015 ARM";
archMacro = "-DCLI_CMAKE_PLATFORM_ARCH_ARM=1";
cmakeArgList.Add("-DCMAKE_SYSTEM_VERSION=10.0");
arch = "arm";
break;
case "arm64":
cmakeBaseRid = "-DCLI_CMAKE_PKG_RID:STRING=win10-arm64";
visualStudio = "Visual Studio 14 2015 Win64";
archMacro = "-DCLI_CMAKE_PLATFORM_ARCH_ARM64=1";
arch = "arm64";
if (Environment.GetEnvironmentVariable("__ToolsetDir") == null)
{
throw new Exception("Toolset Dir must be set when the Platform is ARM64");
}
break;
case "x64":
cmakeBaseRid = "-DCLI_CMAKE_PKG_RID:STRING=win7-x64";
visualStudio = "Visual Studio 14 2015 Win64";
archMacro = "-DCLI_CMAKE_PLATFORM_ARCH_AMD64=1";
arch = "x64";
break;
default:
throw new PlatformNotSupportedException("Target Architecture: " + platform + " is not currently supported.");
}
cmakeArgList.Add(corehostSrcDir);
cmakeArgList.Add(archMacro);
cmakeArgList.Add(cmakeHostVer);
cmakeArgList.Add(cmakeAppHostVer);
cmakeArgList.Add(cmakeHostFxrVer);
cmakeArgList.Add(cmakeHostPolicyVer);
cmakeArgList.Add(cmakeBaseRid);
cmakeArgList.Add(cmakeCommitHash);
cmakeArgList.Add(cmakeResourceDir);
cmakeArgList.Add("-G");
cmakeArgList.Add(visualStudio);
if (linkPortable)
{
cmakeArgList.Add("-DCLI_CMAKE_PORTABLE_BUILD=1");
}
ExecIn(cmakeOut, "cmake", cmakeArgList);
var pf32 = RuntimeInformation.OSArchitecture == Architecture.X64 ?
Environment.GetEnvironmentVariable("ProgramFiles(x86)") :
Environment.GetEnvironmentVariable("ProgramFiles");
string msbuildPath = Path.Combine(pf32, "MSBuild", "14.0", "Bin", "MSBuild.exe");
string cmakeOutPath = Path.Combine(cmakeOut, "ALL_BUILD.vcxproj");
string configParameter = $"/p:Configuration={configuration}";
if (arch == "arm64")
{
Exec(msbuildPath, cmakeOutPath, configParameter, "/p:useEnv=true");
}
else
{
Exec(msbuildPath, cmakeOutPath, configParameter);
}
// Copy the output out
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "dotnet", configuration, "dotnet.exe"), Path.Combine(Dirs.CorehostLatest, "dotnet.exe"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "dotnet", configuration, "dotnet.pdb"), Path.Combine(Dirs.CorehostLatest, "dotnet.pdb"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "apphost", configuration, "apphost.exe"), Path.Combine(Dirs.CorehostLatest, "apphost.exe"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "apphost", configuration, "apphost.pdb"), Path.Combine(Dirs.CorehostLatest, "apphost.pdb"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "dll", configuration, "hostpolicy.dll"), Path.Combine(Dirs.CorehostLatest, "hostpolicy.dll"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "dll", configuration, "hostpolicy.pdb"), Path.Combine(Dirs.CorehostLatest, "hostpolicy.pdb"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "fxr", configuration, "hostfxr.dll"), Path.Combine(Dirs.CorehostLatest, "hostfxr.dll"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "fxr", configuration, "hostfxr.pdb"), Path.Combine(Dirs.CorehostLatest, "hostfxr.pdb"), overwrite: true);
}
else
{
string arch;
switch (platform.ToLower())
{
case "x64":
arch = "x64";
break;
case "arm":
arch = "arm";
break;
case "armel":
arch = "armel";
break;
case "arm64":
arch = "arm64";
break;
default:
throw new PlatformNotSupportedException("Target Architecture: " + platform + " is not currently supported.");
}
// Why does Windows directly call cmake but Linux/Mac calls "build.sh" in the corehost dir?
// See the comment in "src/corehost/build.sh" for details. It doesn't work for some reason.
List <string> buildScriptArgList = new List <string>();
string buildScriptFile = Path.Combine(corehostSrcDir, "build.sh");
buildScriptArgList.Add("--configuration");
buildScriptArgList.Add(configuration);
buildScriptArgList.Add("--arch");
buildScriptArgList.Add(arch);
buildScriptArgList.Add("--hostver");
buildScriptArgList.Add(hostVersion.LatestHostVersion.ToString());
buildScriptArgList.Add("--apphostver");
buildScriptArgList.Add(hostVersion.LatestAppHostVersion.ToString());
buildScriptArgList.Add("--fxrver");
buildScriptArgList.Add(hostVersion.LatestHostFxrVersion.ToString());
buildScriptArgList.Add("--policyver");
buildScriptArgList.Add(hostVersion.LatestHostPolicyVersion.ToString());
buildScriptArgList.Add("--commithash");
buildScriptArgList.Add(commitHash);
if (string.Equals(crossEnv, "1"))
{
buildScriptArgList.Add("--cross");
}
if (linkPortable)
{
buildScriptArgList.Add("-portable");
}
ExecIn(cmakeOut, buildScriptFile, buildScriptArgList);
// Copy the output out
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "dotnet", "dotnet"), Path.Combine(Dirs.CorehostLatest, "dotnet"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "exe", "apphost", "apphost"), Path.Combine(Dirs.CorehostLatest, "apphost"), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "dll", HostArtifactNames.HostPolicyBaseName), Path.Combine(Dirs.CorehostLatest, HostArtifactNames.HostPolicyBaseName), overwrite: true);
File.Copy(Path.Combine(cmakeOut, "cli", "fxr", HostArtifactNames.DotnetHostFxrBaseName), Path.Combine(Dirs.CorehostLatest, HostArtifactNames.DotnetHostFxrBaseName), overwrite: true);
}
return(c.Success());
}
public static BuildTargetResult Prepare(BuildTargetContext c) => c.Success();
public static BuildTargetResult Compile(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult CheckCoreclrPlatformDependencies(BuildTargetContext c) => c.Success();
public static BuildTargetResult UpdateFiles(BuildTargetContext c) => c.Success();
public static BuildTargetResult PublishInstallerFilesToAzure(BuildTargetContext c) => c.Success();
public static BuildTargetResult ReplaceVersions(BuildTargetContext c) => c.Success();
public static BuildTargetResult PublishDebFilesToDebianRepo(BuildTargetContext c)
{
return(c.Success());
}
public static BuildTargetResult ExtractEngineFromBundle(BuildTargetContext c)
{
ExtractEngineFromBundleHelper(SharedFrameworkBundle, SharedFrameworkEngine);
return(c.Success());
}
public static BuildTargetResult BuildTestAssetPackages(BuildTargetContext c)
{
CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "TestPackages"));
var dotnet = DotNetCli.Stage2;
Rmdir(Dirs.TestPackages);
Mkdirp(Dirs.TestPackages);
foreach (var testPackageProject in TestPackageProjects.Projects.Where(p => p.IsApplicable))
{
var relativePath = testPackageProject.Path;
var versionSuffix = testPackageProject.VersionSuffix;
if (versionSuffix.Equals(s_testPackageBuildVersionSuffix))
{
versionSuffix = c.BuildContext.Get <BuildVersion>("BuildVersion").CommitCountString;
}
var fullPath = Path.Combine(c.BuildContext.BuildDirectory, relativePath.Replace('/', Path.DirectorySeparatorChar));
c.Info($"Packing: {fullPath}");
var packageBuildFrameworks = testPackageProject.Frameworks.ToList();
if (!CurrentPlatform.IsWindows)
{
packageBuildFrameworks.RemoveAll(f => f.StartsWith("net4"));
}
foreach (var packageBuildFramework in packageBuildFrameworks)
{
var buildArgs = new List <string>();
buildArgs.Add("-f");
buildArgs.Add(packageBuildFramework);
buildArgs.Add("--build-base-path");
buildArgs.Add(Dirs.TestPackagesBuild);
buildArgs.Add(fullPath);
Mkdirp(Dirs.TestPackagesBuild);
dotnet.Build(buildArgs.ToArray())
.Execute()
.EnsureSuccessful();
}
var projectJson = Path.Combine(fullPath, "project.json");
var dotnetPackArgs = new List <string> {
projectJson,
"--no-build",
"--build-base-path", Dirs.TestPackagesBuild,
"--output", Dirs.TestPackages
};
if (!string.IsNullOrEmpty(versionSuffix))
{
dotnetPackArgs.Add("--version-suffix");
dotnetPackArgs.Add(versionSuffix);
}
dotnet.Pack(dotnetPackArgs.ToArray())
.Execute()
.EnsureSuccessful();
}
return(c.Success());
}
public static BuildTargetResult ReattachEngineToBundle(BuildTargetContext c)
{
ReattachEngineToBundleHelper(SharedFrameworkBundle, SharedFrameworkEngine);
return(c.Success());
}
public static BuildTargetResult SetupTests(BuildTargetContext c) => c.Success();
public static BuildTargetResult PackagePkgProjects(BuildTargetContext c)
{
var arch = IsWinx86 ? "x86" : "x64";
var hostVersion = c.BuildContext.Get <HostVersion>("HostVersion");
var hostNugetversion = hostVersion.LatestHostVersion;
var content = $@"{c.BuildContext["CommitHash"]}{Environment.NewLine}{hostNugetversion}{Environment.NewLine}";
var pkgDir = Path.Combine(c.BuildContext.BuildDirectory, "pkg");
File.WriteAllText(Path.Combine(pkgDir, "version.txt"), content);
if (CurrentPlatform.IsWindows)
{
Command.Create(Path.Combine(pkgDir, "pack.cmd"))
// Workaround to arg escaping adding backslashes for arguments to .cmd scripts.
.Environment("__WorkaroundCliCoreHostBuildArch", arch)
.Environment("__WorkaroundCliCoreHostBinDir", Dirs.CorehostLatest)
.Environment("__WorkaroundCliCoreHostPolicyVer", hostVersion.LatestHostPolicyVersionNoSuffix)
.Environment("__WorkaroundCliCoreHostFxrVer", hostVersion.LatestHostFxrVersionNoSuffix)
.Environment("__WorkaroundCliCoreHostVer", hostVersion.LatestHostVersionNoSuffix)
.Environment("__WorkaroundCliCoreHostBuildMajor", hostVersion.LatestHostBuildMajor)
.Environment("__WorkaroundCliCoreHostBuildMinor", hostVersion.LatestHostBuildMinor)
.Environment("__WorkaroundCliCoreHostVersionTag", hostVersion.LatestHostPrerelease)
.ForwardStdOut()
.ForwardStdErr()
.Execute()
.EnsureSuccessful();
}
else
{
Exec(Path.Combine(pkgDir, "pack.sh"),
"--arch",
"x64",
"--hostbindir",
Dirs.CorehostLatest,
"--policyver",
hostVersion.LatestHostPolicyVersionNoSuffix,
"--fxrver",
hostVersion.LatestHostFxrVersionNoSuffix,
"--hostver",
hostVersion.LatestHostVersionNoSuffix,
"--build-major",
hostVersion.LatestHostBuildMajor,
"--build-minor",
hostVersion.LatestHostBuildMinor,
"--vertag",
hostVersion.LatestHostPrerelease);
}
foreach (var file in Directory.GetFiles(Path.Combine(pkgDir, "bin", "packages"), "*.nupkg"))
{
var fileName = Path.GetFileName(file);
File.Copy(file, Path.Combine(Dirs.CorehostLocalPackages, fileName), true);
Console.WriteLine($"Copying package {fileName} to artifacts directory {Dirs.CorehostLocalPackages}.");
}
foreach (var item in hostVersion.LatestHostPackages)
{
var fileFilter = $"runtime.{HostPackagePlatformRid}.{item.Key}.{item.Value}.nupkg";
if (Directory.GetFiles(Dirs.CorehostLocalPackages, fileFilter).Length == 0)
{
throw new BuildFailureException($"Nupkg for {fileFilter} was not created.");
}
}
return(c.Success());
}
