public static BuildTargetResult GenerateSdkDeb(BuildTargetContext c) { // 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(); } 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 sdkPublishRoot = c.BuildContext.Get<string>("CLISDKRoot"); var sharedFxDebianPackageName = Monikers.GetDebianSharedFrameworkPackageName(CliDependencyVersions.SharedFrameworkVersion); var debianConfigFile = Path.Combine(Dirs.DebPackagingConfig, "dotnet-debian_config.json"); var postinstallFile = Path.Combine(Dirs.DebPackagingConfig, "postinst"); var debianConfigVariables = new Dictionary<string, string>() { { "SHARED_FRAMEWORK_DEBIAN_PACKAGE_NAME", sharedFxDebianPackageName }, { "SHARED_FRAMEWORK_NUGET_NAME", Monikers.SharedFrameworkName }, { "SHARED_FRAMEWORK_NUGET_VERSION", CliDependencyVersions.SharedFrameworkVersion }, { "SHARED_FRAMEWORK_BRAND_NAME", Monikers.SharedFxBrandName }, { "SDK_NUGET_VERSION", version }, { "CLI_SDK_BRAND_NAME", Monikers.CLISdkBrandName } }; var debCreator = new DebPackageCreator( DotNetCli.Stage2, Dirs.Intermediate); debCreator.CreateDeb( debianConfigFile, packageName, version, sdkPublishRoot, debianConfigVariables, debFile, manpagesDirectory: manPagesDir, versionManpages: true, debianFiles: new string[] { postinstallFile }); return c.Success(); }
public static BuildTargetResult GenerateSdkDeb(BuildTargetContext c) { var channel = c.BuildContext.Get<string>("Channel").ToLower(); var packageName = Monikers.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(c); 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, "-m", manPagesDir, "--framework-debian-package-name", sharedFxDebianPackageName, "--framework-nuget-name", Monikers.SharedFrameworkName, "--framework-nuget-version", c.BuildContext.Get<string>("SharedFrameworkNugetVersion"), "--previous-version-url", previousVersionURL, "--obj-root", objRoot) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult GenerateCLISdkProductArchive(BuildTargetContext c) { string resourcePath = Path.Combine(Dirs.RepoRoot, "packaging", "osx", "clisdk", "resources"); string outFilePath = Path.Combine(Dirs.Packages, c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile")); string inputDistTemplatePath = Path.Combine( Dirs.RepoRoot, "packaging", "osx", "clisdk", "Distribution-Template"); string distTemplate = File.ReadAllText(inputDistTemplatePath); string distributionPath = Path.Combine(PkgsIntermediateDir, "CLI-SDK-Formatted-Distribution-Template.xml"); string formattedDistContents = distTemplate.Replace("{SharedFxComponentId}", SharedFxComponentId) .Replace("{SharedHostComponentId}", SharedHostComponentId) .Replace("{CLISdkComponentId}", CLISdkComponentId); File.WriteAllText(distributionPath, formattedDistContents); Cmd("productbuild", "--version", CLISdkNugetVersion, "--identifier", CLISdkPkgId, "--package-path", PkgsIntermediateDir, "--resources", resourcePath, "--distribution", distributionPath, outFilePath) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult GenerateVersions(BuildTargetContext c) { var gitResult = Cmd("git", "rev-list", "--count", "HEAD") .CaptureStdOut() .Execute(); gitResult.EnsureSuccessful(); var commitCount = int.Parse(gitResult.StdOut); gitResult = Cmd("git", "rev-parse", "HEAD") .CaptureStdOut() .Execute(); gitResult.EnsureSuccessful(); var commitHash = gitResult.StdOut.Trim(); var branchInfo = ReadBranchInfo(c, Path.Combine(c.BuildContext.BuildDirectory, "branchinfo.txt")); var buildVersion = new BuildVersion() { Major = int.Parse(branchInfo["MAJOR_VERSION"]), Minor = int.Parse(branchInfo["MINOR_VERSION"]), Patch = int.Parse(branchInfo["PATCH_VERSION"]), ReleaseSuffix = branchInfo["RELEASE_SUFFIX"], CommitCount = commitCount }; c.BuildContext["BuildVersion"] = buildVersion; c.BuildContext["CommitHash"] = commitHash; c.Info($"Building Version: {buildVersion.SimpleVersion} (NuGet Packages: {buildVersion.NuGetVersion})"); c.Info($"From Commit: {commitHash}"); return c.Success(); }
public static BuildTargetResult PublishVersionBadge(BuildTargetContext c) { var versionBadge = c.BuildContext.Get<string>("VersionBadge"); var latestVersionBadgeBlob = $"{Channel}/Binaries/Latest/{Path.GetFileName(versionBadge)}"; var versionBadgeBlob = $"{Channel}/Binaries/{Version}/{Path.GetFileName(versionBadge)}"; PublishFileAzure(versionBadgeBlob, versionBadge); PublishFileAzure(latestVersionBadgeBlob, versionBadge); return c.Success(); }
public static BuildTargetResult InitPublish(BuildTargetContext c) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("CONNECTION_STRING").Trim('"')); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); BlobContainer = blobClient.GetContainerReference("dotnet"); Version = c.BuildContext.Get<BuildVersion>("BuildVersion").SimpleVersion; Channel = c.BuildContext.Get<string>("Channel"); return c.Success(); }
public static BuildTargetResult GeneratePkg(BuildTargetContext c) { var version = c.BuildContext.Get<BuildVersion>("BuildVersion").SimpleVersion; var pkg = c.BuildContext.Get<string>("InstallerFile"); Cmd(Path.Combine(Dirs.RepoRoot, "packaging", "osx", "package-osx.sh"), "-v", version, "-i", Dirs.Stage2, "-o", pkg) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult PublishCompressedFile(BuildTargetContext c) { var compressedFile = c.BuildContext.Get<string>("CompressedFile"); var compressedFileBlob = $"{Channel}/Binaries/{Version}/{Path.GetFileName(compressedFile)}"; var latestCompressedFile = compressedFile.Replace(Version, "latest"); var latestCompressedFileBlob = $"{Channel}/Binaries/Latest/{Path.GetFileName(latestCompressedFile)}"; PublishFileAzure(compressedFileBlob, compressedFile); PublishFileAzure(latestCompressedFileBlob, compressedFile); return c.Success(); }
public static BuildTargetResult RestoreTestAssetPackages(BuildTargetContext c) { CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "test")); CleanNuGetTempCache(); var dotnet = DotNetCli.Stage2; dotnet.Restore().WorkingDirectory(Path.Combine(c.BuildContext.BuildDirectory, "TestAssets", "TestPackages")).Execute().EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult GenerateVersionBadge(BuildTargetContext c) { var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion"); var versionSvg = Path.Combine(Dirs.RepoRoot, "resources", "images", "version_badge.svg"); var outputVersionSvg = c.BuildContext.Get<string>("VersionBadge"); var versionSvgContent = File.ReadAllText(versionSvg); versionSvgContent = versionSvgContent.Replace("ver_number", buildVersion.SimpleVersion); File.WriteAllText(outputVersionSvg, versionSvgContent); return c.Success(); }
public static BuildTargetResult InitPublish(BuildTargetContext c) { AzurePublisherTool = new AzurePublisher(); DebRepoPublisherTool = new DebRepoPublisher(Dirs.Packages); CliVersion = c.BuildContext.Get<BuildVersion>("BuildVersion").SimpleVersion; CliNuGetVersion = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion; SharedFrameworkNugetVersion = c.BuildContext.Get<string>("SharedFrameworkNugetVersion"); Channel = c.BuildContext.Get<string>("Channel"); return c.Success(); }
public static BuildTargetResult GenerateZip(BuildTargetContext c) { var zipFile = c.BuildContext.Get<string>("CompressedFile"); if (File.Exists(zipFile)) { File.Delete(zipFile); } ZipFile.CreateFromDirectory(Dirs.Stage2, zipFile, CompressionLevel.Optimal, false); return c.Success(); }
public static BuildTargetResult GenerateTarBall(BuildTargetContext c) { var tarFile = c.BuildContext.Get<string>("CompressedFile"); if (File.Exists(tarFile)) { File.Delete(tarFile); } Cmd("tar", "-czf", tarFile, "-C", Dirs.Stage2, ".") .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult InitMsi(BuildTargetContext c) { Bundle = c.BuildContext.Get<string>("InstallerFile"); Msi = Path.ChangeExtension(Bundle, "msi"); Engine = Path.Combine(Path.GetDirectoryName(Bundle), ENGINE); var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion"); MsiVersion = buildVersion.GenerateMsiVersion(); CliVersion = buildVersion.SimpleVersion; Channel = c.BuildContext.Get<string>("Channel"); AcquireWix(c); return c.Success(); }
public static BuildTargetResult FinalizeBuild(BuildTargetContext c) { if (CheckIfAllBuildsHavePublished()) { string targetContainer = $"{AzurePublisher.Product.Sdk}/{Channel}"; string targetVersionFile = $"{targetContainer}/{CommitHash}"; string semaphoreBlob = $"{targetContainer}/publishSemaphore"; AzurePublisherTool.CreateBlobIfNotExists(semaphoreBlob); string leaseId = AzurePublisherTool.AcquireLeaseOnBlob(semaphoreBlob); // Prevent race conditions by dropping a version hint of what version this is. If we see this file // and it is the same as our version then we know that a race happened where two+ builds finished // at the same time and someone already took care of publishing and we have no work to do. if (AzurePublisherTool.IsLatestSpecifiedVersion(targetVersionFile)) { AzurePublisherTool.ReleaseLeaseOnBlob(semaphoreBlob, leaseId); return c.Success(); } else { Regex versionFileRegex = new Regex(@"(?<CommitHash>[\w\d]{40})"); // Delete old version files AzurePublisherTool.ListBlobs(targetContainer) .Where(s => versionFileRegex.IsMatch(s)) .ToList() .ForEach(f => AzurePublisherTool.TryDeleteBlob(f)); // Drop the version file signaling such for any race-condition builds (see above comment). AzurePublisherTool.DropLatestSpecifiedVersion(targetVersionFile); } try { CopyBlobsToLatest(targetContainer); string cliVersion = Utils.GetCliVersionFileContent(c); AzurePublisherTool.PublishStringToBlob($"{targetContainer}/latest.version", cliVersion); UpdateVersionsRepo(c); } finally { AzurePublisherTool.ReleaseLeaseOnBlob(semaphoreBlob, leaseId); } } return c.Success(); }
public static BuildTargetResult GenerateDeb(BuildTargetContext c) { var channel = c.BuildContext.Get<string>("Channel").ToLower(); var packageName = Monikers.GetDebianPackageName(c); var version = c.BuildContext.Get<BuildVersion>("BuildVersion").SimpleVersion; var debFile = c.BuildContext.Get<string>("InstallerFile"); 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"; Cmd(Path.Combine(Dirs.RepoRoot, "scripts", "package", "package-debian.sh"), "-v", version, "-i", Dirs.Stage2, "-o", debFile, "-p", packageName, "-m", manPagesDir, "--previous-version-url", previousVersionURL) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult CopyCLISDKLayout(BuildTargetContext c) { var cliSdkRoot = Path.Combine(Dirs.Output, "obj", "clisdk"); if (Directory.Exists(cliSdkRoot)) { Utils.DeleteDirectory(cliSdkRoot); } Directory.CreateDirectory(cliSdkRoot); Utils.CopyDirectoryRecursively(Path.Combine(Dirs.Stage2, "sdk"), cliSdkRoot, true); FixPermissions(cliSdkRoot); c.BuildContext["CLISDKRoot"] = cliSdkRoot; return c.Success(); }
public static BuildTargetResult RestoreTestPrerequisites(BuildTargetContext c) { CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "src")); CleanBinObj(c, Path.Combine(c.BuildContext.BuildDirectory, "test")); CleanNuGetTempCache(); var dotnet = DotNetCli.Stage2; dotnet.Restore().WorkingDirectory(Path.Combine(c.BuildContext.BuildDirectory, "TestAssets")).Execute().EnsureSuccessful(); // The 'testapp' directory contains intentionally-unresolved dependencies, so don't check for success. Also, suppress the output dotnet.Restore().WorkingDirectory(Path.Combine(c.BuildContext.BuildDirectory, "testapp")).CaptureStdErr().CaptureStdOut().Execute(); return c.Success(); }
public static BuildTargetResult CommitChanges(BuildTargetContext c) { Cmd("git", "add", ".") .Execute() .EnsureSuccessful(); string userName = s_config.UserName; string email = s_config.Email; Cmd("git", "commit", "-m", PullRequestTitle, "--author", $"{userName} <{email}>") .EnvironmentVariable("GIT_COMMITTER_NAME", userName) .EnvironmentVariable("GIT_COMMITTER_EMAIL", email) .Execute() .EnsureSuccessful(); string remoteUrl = $"github.com/{s_config.GitHubOriginOwner}/{s_config.GitHubProject}.git"; string remoteBranchName = $"UpdateDependencies{DateTime.UtcNow.ToString("yyyyMMddhhmmss")}"; string refSpec = $"HEAD:refs/heads/{remoteBranchName}"; string logMessage = $"git push https://{remoteUrl} {refSpec}"; BuildReporter.BeginSection("EXEC", logMessage); CommandResult pushResult = Cmd("git", "push", $"https://{userName}:{s_config.Password}@{remoteUrl}", refSpec) .QuietBuildReporter() // we don't want secrets showing up in our logs .CaptureStdErr() // git push will write to StdErr upon success, disable that .CaptureStdOut() .Execute(); var message = logMessage + $" exited with {pushResult.ExitCode}"; if (pushResult.ExitCode == 0) { BuildReporter.EndSection("EXEC", message.Green(), success: true); } else { BuildReporter.EndSection("EXEC", message.Red().Bold(), success: false); } pushResult.EnsureSuccessful(suppressOutput: true); c.SetRemoteBranchName(remoteBranchName); return c.Success(); }
public static BuildTargetResult GetDependencies(BuildTargetContext c) { string coreFxLkgVersion = s_client.GetStringAsync(Config.Instance.CoreFxVersionUrl).Result; coreFxLkgVersion = coreFxLkgVersion.Trim(); const string coreFxIdPattern = @"^(?i)((System\..*)|(NETStandard\.Library)|(Microsoft\.CSharp)|(Microsoft\.NETCore.*)|(Microsoft\.TargetingPack\.Private\.(CoreCLR|NETNative))|(Microsoft\.Win32\..*)|(Microsoft\.VisualBasic))$"; const string coreFxIdExclusionPattern = @"System.CommandLine"; List<DependencyInfo> dependencyInfos = c.GetDependencyInfos(); dependencyInfos.Add(new DependencyInfo() { Name = "CoreFx", IdPattern = coreFxIdPattern, IdExclusionPattern = coreFxIdExclusionPattern, NewReleaseVersion = coreFxLkgVersion }); return c.Success(); }
public static BuildTargetResult Init(BuildTargetContext c) { var configEnv = Environment.GetEnvironmentVariable("CONFIGURATION"); if (string.IsNullOrEmpty(configEnv)) { configEnv = "Debug"; } c.BuildContext["Configuration"] = configEnv; c.BuildContext["Channel"] = Environment.GetEnvironmentVariable("CHANNEL"); c.Info($"Building {c.BuildContext["Configuration"]} to: {Dirs.Output}"); c.Info("Build Environment:"); c.Info($" Operating System: {RuntimeEnvironment.OperatingSystem} {RuntimeEnvironment.OperatingSystemVersion}"); c.Info($" Platform: {RuntimeEnvironment.OperatingSystemPlatform}"); return c.Success(); }
public static BuildTargetResult InitMsi(BuildTargetContext c) { SdkBundle = c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile"); SdkMsi = Path.ChangeExtension(SdkBundle, "msi"); SdkEngine = GetEngineName(SdkBundle); SharedFrameworkBundle = c.BuildContext.Get<string>("CombinedFrameworkHostInstallerFile"); SharedHostMsi = Path.ChangeExtension(c.BuildContext.Get<string>("SharedHostInstallerFile"), "msi"); SharedFrameworkMsi = Path.ChangeExtension(c.BuildContext.Get<string>("SharedFrameworkInstallerFile"), "msi"); SharedFrameworkEngine = GetEngineName(SharedFrameworkBundle); var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion"); MsiVersion = buildVersion.GenerateMsiVersion(); CliVersion = buildVersion.SimpleVersion; Channel = c.BuildContext.Get<string>("Channel"); AcquireWix(c); return c.Success(); }
public static BuildTargetResult InitPkg(BuildTargetContext c) { PkgsIntermediateDir = Path.Combine(Dirs.Packages, "intermediate"); Directory.CreateDirectory(PkgsIntermediateDir); SharedHostComponentId = $"com.microsoft.dotnet.sharedhost.component.osx.x64"; HostFxrComponentId = $"com.microsoft.dotnet.hostfxr.component.osx.x64"; string sharedFrameworkNugetName = Monikers.SharedFrameworkName; SharedFrameworkNugetVersion = CliDependencyVersions.SharedFrameworkVersion; SharedFxComponentId = $"com.microsoft.dotnet.sharedframework.{sharedFrameworkNugetName}.{SharedFrameworkNugetVersion}.component.osx.x64"; SharedFxPkgId = $"com.microsoft.dotnet.{sharedFrameworkNugetName}.{SharedFrameworkNugetVersion}.osx.x64"; CLISdkNugetVersion = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion; CLISdkComponentId = $"com.microsoft.dotnet.dev.{CLISdkNugetVersion}.component.osx.x64"; CLISdkPkgId = $"com.microsoft.dotnet.dev.{CLISdkNugetVersion}.osx.x64"; return c.Success(); }
public static BuildTargetResult GenerateSharedHostDeb(BuildTargetContext c) { var packageName = Monikers.GetDebianSharedHostPackageName(c); var version = c.BuildContext.Get<BuildVersion>("BuildVersion").NuGetVersion; var inputRoot = c.BuildContext.Get<string>("SharedHostPublishRoot"); var debFile = c.BuildContext.Get<string>("SharedHostInstallerFile"); var objRoot = Path.Combine(Dirs.Output, "obj", "debian", "sharedhost"); var manPagesDir = Path.Combine(Dirs.RepoRoot, "Documentation", "manpages"); if (Directory.Exists(objRoot)) { Directory.Delete(objRoot, true); } Directory.CreateDirectory(objRoot); Cmd(Path.Combine(Dirs.RepoRoot, "scripts", "package", "package-sharedhost-debian.sh"), "--input", inputRoot, "--output", debFile, "--obj-root", objRoot, "--version", version, "-m", manPagesDir) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult GenerateVersions(BuildTargetContext c) { var commitCount = GitUtils.GetCommitCount(); var commitHash = GitUtils.GetCommitHash(); var branchInfo = ReadBranchInfo(c, Path.Combine(c.BuildContext.BuildDirectory, "branchinfo.txt")); var buildVersion = new BuildVersion() { Major = int.Parse(branchInfo["MAJOR_VERSION"]), Minor = int.Parse(branchInfo["MINOR_VERSION"]), Patch = int.Parse(branchInfo["PATCH_VERSION"]), ReleaseSuffix = branchInfo["RELEASE_SUFFIX"], CommitCount = commitCount }; c.BuildContext["BuildVersion"] = buildVersion; c.BuildContext["BranchName"] = branchInfo["BRANCH_NAME"]; c.BuildContext["CommitHash"] = commitHash; c.Info($"Building Version: {buildVersion.SimpleVersion} (NuGet Packages: {buildVersion.NuGetVersion})"); c.Info($"From Commit: {commitHash}"); return c.Success(); }
public static BuildTargetResult GenerateCLISdkProductArchive(BuildTargetContext c) { string resourcePath = Path.Combine(Dirs.RepoRoot, "packaging", "osx", "clisdk", "resources"); string outFilePath = Path.Combine(Dirs.Packages, c.BuildContext.Get<string>("CombinedFrameworkSDKHostInstallerFile")); // 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>("SharedHostInstallerFile"), sharedHostPkgIntermediatePath, true); File.Copy(c.BuildContext.Get<string>("HostFxrInstallerFile"), hostFxrPkgIntermediatePath, true); string inputDistTemplatePath = Path.Combine( Dirs.RepoRoot, "packaging", "osx", "clisdk", "Distribution-Template"); string distTemplate = File.ReadAllText(inputDistTemplatePath); string distributionPath = Path.Combine(PkgsIntermediateDir, "CLI-SDK-Formatted-Distribution-Template.xml"); string formattedDistContents = distTemplate.Replace("{SharedFxComponentId}", SharedFxComponentId) .Replace("{SharedHostComponentId}", SharedHostComponentId) .Replace("{HostFxrComponentId}", HostFxrComponentId) .Replace("{CLISdkComponentId}", CLISdkComponentId) .Replace("{CLISdkNugetVersion}", CLISdkNugetVersion) .Replace("{CLISdkBrandName}", Monikers.CLISdkBrandName) .Replace("{SharedFxBrandName}", Monikers.SharedFxBrandName) .Replace("{SharedHostBrandName}", Monikers.SharedHostBrandName) .Replace("{HostFxrBrandName}", Monikers.HostFxrBrandName); File.WriteAllText(distributionPath, formattedDistContents); Cmd("productbuild", "--version", CLISdkNugetVersion, "--identifier", CLISdkPkgId, "--package-path", PkgsIntermediateDir, "--resources", resourcePath, "--distribution", distributionPath, outFilePath) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult GeneratePkgs(BuildTargetContext c) { return c.Success(); }
public static BuildTargetResult GenerateCLISdkPkg(BuildTargetContext c) { 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", "--root", c.BuildContext.Get<string>("CLISDKRoot"), "--identifier", CLISdkComponentId, "--version", CLISdkNugetVersion, "--install-location", installLocation, "--scripts", scriptsLocation, outFilePath) .Execute() .EnsureSuccessful(); return c.Success(); }
public static BuildTargetResult ReattachEngineToBundle(BuildTargetContext c) { ReattachEngineToBundleHelper(SdkBundle, SdkEngine); ReattachEngineToBundleHelper(SharedFrameworkBundle, SharedFrameworkEngine); return c.Success(); }
public static BuildTargetResult ExtractEngineFromBundle(BuildTargetContext c) { ExtractEngineFromBundleHelper(SdkBundle, SdkEngine); ExtractEngineFromBundleHelper(SharedFrameworkBundle, SharedFrameworkEngine); return c.Success(); }