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()); }