protected override async Task RunDistribute(IEnumerable <BuildPath> buildPaths, TaskToken task)
{
if (string.IsNullOrEmpty(scriptPath))
{
throw new Exception("ScriptDistro: Script path not set.");
}
if (individual)
{
task.Report(0, buildPaths.Count());
foreach (var buildPath in buildPaths)
{
task.Report(0, description: $"Running script {Path.GetFileName(scriptPath)} for {buildPath.target}");
var args = ReplaceVariablesIndividual(arguments, buildPath);
await Execute(new ExecutionArgs(scriptPath, args), task);
task.baseStep++;
}
}
else
{
task.Report(0, 1, $"Running script {Path.GetFileName(scriptPath)}");
var args = ReplaceVariables(arguments, buildPaths);
await Execute(new ExecutionArgs(scriptPath, args), task);
}
}
protected async Task Upload(BuildPath zipPath, TaskToken task)
{
var archive = zipPath.path;
if (!File.Exists(archive))
{
throw new System.Exception("UploadDistro: Archive file does not exist: " + archive);
}
// Append a / to the url if necessary, otherwise curl treats the last part as a file name
var url = uploadUrl;
if (url[url.Length - 1] != '/')
{
url += "/";
}
string input = null;
if (!string.IsNullOrEmpty(login.User))
{
input = string.Format("-u \"{0}:{1}\"", login.User, login.GetPassword(keychainService));
}
var arguments = string.Format(
"-T '{0}' {1} --ssl -v '{2}'",
archive, input != null ? "-K -" : "", url
);
task.Report(0, $"Uploading {Path.GetFileName(archive)} to {uploadUrl}");
await Execute(new ExecutionArgs(curlPath, arguments) { input = input }, task);
}
protected override async Task RunDistribute(IEnumerable <BuildPath> buildPaths, TaskToken task)
{
if (!File.Exists(butlerPath))
{
throw new Exception("ItchDistro: Butler path not set or file does not exist.");
}
if (string.IsNullOrEmpty(project))
{
throw new Exception("ItchDistro: project not set.");
}
task.Report(0, buildPaths.Count());
foreach (var pair in buildPaths)
{
if (!ChannelNames.ContainsKey(pair.target))
{
Debug.LogWarning("ItchDistro: Build target " + pair.target + " not supported, skipping.");
continue;
}
if (macNotarization != null)
{
await macNotarization.NotarizeIfMac(pair, task);
}
await Distribute(pair, task);
task.baseStep++;
}
}
protected override async Task RunDistribute(IEnumerable <BuildPath> buildPaths, TaskToken task)
{
if (string.IsNullOrEmpty(curlPath))
{
throw new Exception("UploadDistro: Path to curl not set.");
}
if (!File.Exists(curlPath))
{
throw new Exception("UploadDistro: curl not found at path: " + curlPath);
}
if (string.IsNullOrEmpty(uploadUrl))
{
throw new Exception("UploadDistro: No upload URL set.");
}
if (!string.IsNullOrEmpty(login.User) && login.GetPassword(keychainService) == null)
{
throw new Exception("UploadDistro: No password set for user: "******"Archiving builds");
IEnumerable <BuildPath> zipPaths;
var child = task.StartChild("Zip Builds");
try {
zipPaths = await ZipBuilds(buildPaths, child);
} finally {
child.Remove();
}
task.Report(1, description: "Uploading builds");
child = task.StartChild("Upload Builds");
try {
foreach (var path in zipPaths)
{
await Upload(path, child);
}
} finally {
child.Remove();
}
}
void TaskBuild(Job job)
{
// Handle switching build target when necessary
var activeTargetMatches = (EditorUserBuildSettings.activeBuildTarget == job.target);
if (continueTask == ContinueTask.BuildAfterSwitchingTarget && !activeTargetMatches)
{
throw new Exception($"Trimmer BuildRunner: Failed to switch active build target to {job.target}.");
}
else if (!activeTargetMatches)
{
token.Report(jobIndex, description: $"Switching active build target to {job.target}");
var group = BuildPipeline.GetBuildTargetGroup(job.target);
EditorUserBuildSettings.SwitchActiveBuildTarget(group, job.target);
ContinueWith(ContinueTask.BuildAfterSwitchingTarget, afterDomainRelaod: true);
return;
}
// Build
token.Report(jobIndex, description: $"Building {job.target}");
BuildReport report;
try {
var options = BuildManager.GetDefaultOptions(job.target);
if (!string.IsNullOrEmpty(job.outputPath))
{
options.locationPathName = job.outputPath;
}
report = BuildManager.BuildSync(job.profile, options);
results[jobIndex].report = report;
} catch (Exception e) {
results[jobIndex] = ProfileBuildResult.Error(job.profile, e.Message);
throw;
}
if (report.summary.result != BuildResult.Succeeded)
{
throw new Exception($"Trimmer BuildRunner: Build failed");
}
ContinueWith(ContinueTask.NextJob);
}
protected async Task Process(string path, TaskToken task)
{
task.Report(0, 2);
// Create archive
var projectPath = Path.Combine(path, "Unity-iPhone.xcodeproj");
if (!Directory.Exists(projectPath))
{
throw new Exception($"iOSDistro: Could not find Xcode project at path '{projectPath}'");
}
var archiveName = $"{scheme}-{PlayerSettings.iOS.buildNumber}-{DateTime.Now.ToString("O")}.xcarchive";
var archivePath = Path.Combine(archivesPath, archiveName);
task.Report(0, description: $"Building scheme '{scheme}'");
await Archive(projectPath, scheme, archivePath, task);
// Upload archive
var cleanUpOptions = false;
string exportOptionsPath = null;
try {
if (exportOptions != null)
{
exportOptionsPath = AssetDatabase.GetAssetPath(exportOptions);
}
if (string.IsNullOrEmpty(exportOptionsPath))
{
cleanUpOptions = true;
exportOptionsPath = Path.GetTempFileName();
File.WriteAllText(exportOptionsPath, DefaultExportOptions);
}
task.Report(1, description: $"Uploading archive");
await Upload(archivePath, exportOptionsPath, task);
} finally {
if (cleanUpOptions)
{
File.Delete(exportOptionsPath);
}
}
}
protected async Task <IEnumerable <BuildPath> > ZipBuilds(IEnumerable <BuildPath> buildPaths, TaskToken task)
{
var queue = new Queue <BuildPath>(buildPaths);
var results = new List <BuildPath>();
task.Report(0, queue.Count);
while (queue.Count > 0)
{
var next = queue.Dequeue();
if (macNotarization != null)
{
await macNotarization.NotarizeIfMac(next, task);
}
results.Add(await Zip(next, task));
task.baseStep++;
}
return(results);
}
async Task Distribute(BuildPath buildPath, TaskToken task)
{
task.Report(0, description: $"Pushing {buildPath.target}");
var path = OptionHelper.GetBuildBasePath(buildPath.path);
var channel = ChannelNames[buildPath.target];
if (!string.IsNullOrEmpty(channelSuffix))
{
channel += "-" + channelSuffix;
}
var version = Application.version;
var buildInfo = BuildInfo.FromPath(path);
if (buildInfo != null)
{
if (!buildInfo.version.IsDefined)
{
Debug.LogWarning("ItchDistro: build.json exists but contains no version.");
}
else
{
version = buildInfo.version.MajorMinorPatchBuild;
}
}
var args = string.Format(
"push '{0}' '{1}:{2}' --userversion '{3}' --ignore='*.DS_Store' --ignore='build.json'",
path, project, channel, Application.version
);
await Execute(new ExecutionArgs(butlerPath, args), task);
}
/// <summary>
/// Notarize a macOS build.
/// </summary>
/// <remarks>
/// This method will throw if the given build is not a macOS build.
/// </remarks>
/// <param name="macBuildPath">Path to the app bundle</param>
public async Task Notarize(BuildPath macBuildPath, TaskToken task)
{
if (macBuildPath.target != BuildTarget.StandaloneOSX)
{
throw new Exception($"NotarizationDistro: Notarization is only available for macOS builds (got {macBuildPath.target})");
}
var path = macBuildPath.path;
// Check settings
if (string.IsNullOrEmpty(appSignIdentity))
{
throw new Exception("NotarizationDistro: App sign identity not set.");
}
if (entitlements == null)
{
throw new Exception("NotarizationDistro: Entitlements file not set.");
}
// Check User
if (string.IsNullOrEmpty(ascLogin.User))
{
throw new Exception("NotarizationDistro: No App Store Connect user set.");
}
if (ascLogin.GetPassword(keychainService) == null)
{
throw new Exception("NotarizationDistro: No App Store Connect password found in Keychain.");
}
task.Report(0, 6, "Checking if app is already notarized");
// Try stapling in case the build has already been notarized
if (await Staple(path, silentError: true, task))
{
Debug.Log("Build already notarized, nothing more to do...");
return;
}
task.Report(1, description: "Signing app");
// Sign plugins
// codesign --deep --force does not resign nested plugins,
// --force only applies to the main bundle. If we want to
// resign nested plugins, we have to call codesign for each.
// This is required for library validation with the hardened runtime.
var plugins = Path.Combine(path, "Contents/Plugins");
if (Directory.Exists(plugins))
{
await Sign(Directory.GetFiles(plugins, "*.dylib", SearchOption.TopDirectoryOnly), task);
await Sign(Directory.GetFiles(plugins, "*.bundle", SearchOption.TopDirectoryOnly), task);
await Sign(Directory.GetDirectories(plugins, "*.bundle", SearchOption.TopDirectoryOnly), task);
}
// Sign application
var entitlementsPath = AssetDatabase.GetAssetPath(entitlements);
await Sign(path, task, entitlementsPath);
task.Report(2, description: "Zipping app");
// Zip app
var zipPath = path + ".zip";
await Zip(path, zipPath, task);
task.Report(3, description: "Uploading app");
// Upload for notarization
string requestUUID = null;
try {
requestUUID = await Upload(zipPath, task);
if (requestUUID == null)
{
throw new Exception("NotarizationDistro: Could not parse request UUID from upload output");
}
} finally {
// Delete ZIP regardless of upload result
File.Delete(zipPath);
}
task.Report(4, description: "Waiting for notarization result");
// Wait for notarization to complete
var status = await WaitForCompletion(requestUUID, task);
if (status != "success")
{
throw new Exception($"NotarizationDistro: Got '{status}' notarization status");
}
task.Report(5, description: "Stapling ticket to app");
// Staple
await Staple(path, silentError : false, task);
}
protected async Task <BuildPath> Zip(BuildPath buildPath, TaskToken task)
{
var target = buildPath.target;
var path = buildPath.path;
if (!File.Exists(path) && !Directory.Exists(path))
{
throw new Exception("ZipDistro: Path to compress does not exist: " + path);
}
if (ZipIgnorePatterns == null)
{
ZipIgnorePatterns = new Regex[ZipIgnore.Length];
for (int i = 0; i < ZipIgnore.Length; i++)
{
var regex = Regex.Escape(ZipIgnore[i]).Replace(@"\*", ".*").Replace(@"\?", ".");
ZipIgnorePatterns[i] = new Regex(regex);
}
}
var sevenZPath = Get7ZipPath();
// Path can point to executable file but there might be files
// in the containing directory we need as well
var basePath = OptionHelper.GetBuildBasePath(path);
// Check the files in containing directory
var files = new List <string>(Directory.GetFileSystemEntries(basePath));
for (int i = files.Count - 1; i >= 0; i--)
{
var filename = Path.GetFileName(files[i]);
foreach (var pattern in ZipIgnorePatterns)
{
if (pattern.IsMatch(filename))
{
files.RemoveAt(i);
goto ContinueOuter;
}
}
ContinueOuter :;
}
if (files.Count == 0)
{
throw new Exception("ZipDistro: Nothing to ZIP in directory: " + basePath);
}
// Determine output path first to make it consistent and use absolute path
// since the script will be run in a different working directory
var prettyName = GetPrettyName(target);
if (prettyName == null)
{
prettyName = Path.GetFileNameWithoutExtension(basePath);
}
var versionSuffix = "";
if (appendVersion)
{
var buildInfo = BuildInfo.FromPath(path);
if (buildInfo != null)
{
if (!buildInfo.version.IsDefined)
{
Debug.LogWarning("ZipDistro: build.json exists but contains no version");
}
else
{
versionSuffix = " " + buildInfo.version.MajorMinorPatch;
}
}
if (versionSuffix.Length == 0)
{
versionSuffix = " " + Application.version;
}
}
var extension = FileExtensions[(int)format];
var zipName = prettyName + versionSuffix + extension;
zipName = zipName.Replace(" ", "_");
var outputPath = Path.Combine(Path.GetDirectoryName(basePath), zipName);
outputPath = Path.GetFullPath(outputPath);
// Delete existing archive, otherwise 7za will update it
if (File.Exists(outputPath))
{
File.Delete(outputPath);
}
// In case it only contains a single file, just zip that file
var singleFile = false;
if (files.Count == 1)
{
singleFile = true;
basePath = files[0];
}
// Run 7za command to create ZIP file
var excludes = "";
foreach (var pattern in ZipIgnore)
{
excludes += @" -xr\!'" + pattern + "'";
}
var inputName = Path.GetFileName(basePath);
var args = string.Format(
"a '{0}' '{1}' -r -mx{2} {3}",
outputPath, inputName, (int)compression, excludes
);
var startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.FileName = sevenZPath;
startInfo.Arguments = args;
startInfo.WorkingDirectory = Path.GetDirectoryName(basePath);
task.Report(0, description: $"Archiving {inputName}");
await Execute(new ExecutionArgs()
{
startInfo = startInfo
}, task);
if (!singleFile && prettyName != inputName)
{
await RenameRoot(outputPath, inputName, prettyName, task);
}
return(new BuildPath(buildPath.profile, target, outputPath));
}
protected async Task Process(string path, TaskToken task)
{
// Check settings
if (string.IsNullOrEmpty(appSignIdentity))
{
throw new Exception("MASDistro: App sign identity not set.");
}
if (entitlements == null)
{
throw new Exception("MASDistro: Entitlements file not set.");
}
if (provisioningProfile == null)
{
throw new Exception("MASDistro: Provisioning profile not set.");
}
if (linkFrameworks != null && linkFrameworks.Length > 0 && !File.Exists(optoolPath))
{
throw new Exception("MASDistro: optool path not set for linking frameworks.");
}
var plistPath = Path.Combine(path, "Contents/Info.plist");
if (!File.Exists(plistPath))
{
throw new Exception("MASDistro: Info.plist file not found at path: " + plistPath);
}
task.Report(0, 3);
var doc = new PlistDocument();
doc.ReadFromFile(plistPath);
// Edit Info.plist
if (!string.IsNullOrEmpty(copyright) || !string.IsNullOrEmpty(languages))
{
if (!string.IsNullOrEmpty(copyright))
{
doc.root.SetString("NSHumanReadableCopyright", string.Format(copyright, System.DateTime.Now.Year));
}
if (!string.IsNullOrEmpty(languages))
{
var parts = languages.Split(',');
var array = doc.root.CreateArray("CFBundleLocalizations");
foreach (var part in parts)
{
array.AddString(part.Trim());
}
}
doc.WriteToFile(plistPath);
}
// Link frameworks
if (linkFrameworks != null && linkFrameworks.Length > 0)
{
task.Report(0, description: "Linking frameworks");
var binaryPath = Path.Combine(path, "Contents/MacOS");
binaryPath = Path.Combine(binaryPath, doc.root["CFBundleExecutable"].AsString());
foreach (var framework in linkFrameworks)
{
var frameworkBinaryPath = FindFramework(framework);
if (frameworkBinaryPath == null)
{
throw new Exception("MASDistro: Could not locate framework: " + framework);
}
var otoolargs = string.Format(
"install -c weak -p '{0}' -t '{1}'",
frameworkBinaryPath, binaryPath
);
await Execute(new ExecutionArgs(optoolPath, otoolargs), task);
}
}
// Copy provisioning profile
var profilePath = AssetDatabase.GetAssetPath(provisioningProfile);
var embeddedPath = Path.Combine(path, "Contents/embedded.provisionprofile");
File.Copy(profilePath, embeddedPath, true);
// Sign plugins
var plugins = Path.Combine(path, "Contents/Plugins");
if (Directory.Exists(plugins))
{
task.Report(0, description: "Signing plugins");
await Sign(Directory.GetFiles(plugins, "*.dylib", SearchOption.AllDirectories), task);
await Sign(Directory.GetFiles(plugins, "*.bundle", SearchOption.AllDirectories), task);
await Sign(Directory.GetDirectories(plugins, "*.bundle", SearchOption.TopDirectoryOnly), task);
}
// Sign application
task.Report(1, description: "Singing app");
var entitlementsPath = AssetDatabase.GetAssetPath(entitlements);
await Sign(path, task, entitlementsPath);
// Create installer
var pkgPath = Path.ChangeExtension(path, ".pkg");
if (!string.IsNullOrEmpty(installerSignIdentity))
{
task.Report(1, description: "Creating installer");
var args = string.Format(
"--component '{0}' /Applications --sign '{1}' '{2}'",
path, installerSignIdentity, pkgPath
);
await Execute(new ExecutionArgs("productbuild", args), task);
}
// Upload to App Store
if (!string.IsNullOrEmpty(ascLogin.User))
{
task.Report(2, description: "Uploading to App Store Connect");
await Upload(pkgPath, task);
}
}
protected override async Task RunDistribute(IEnumerable <BuildPath> buildPaths, TaskToken task)
{
// Check Pipeline Builder Executable
var cmd = FindPipelineBuilder();
// Check User
if (string.IsNullOrEmpty(gogLogin.User))
{
throw new Exception("GOGDistro: No GOG user set.");
}
if (gogLogin.GetPassword(keychainService) == null)
{
throw new Exception("GOGDistro: No GOG password found in Keychain.");
}
// Check projects
if (string.IsNullOrEmpty(projectsFolder) || !Directory.Exists(projectsFolder))
{
throw new Exception("GOGDistro: Path to projects folder not set.");
}
// Check ignore list
if (!string.IsNullOrEmpty(ignoreList) && !File.Exists(ignoreList))
{
throw new Exception("GOGDistro: Ignore list could not be found: " + ignoreList);
}
// Process projects
var tempDir = FileUtil.GetUniqueTempPathInProject();
try {
Directory.CreateDirectory(tempDir);
var targets = new HashSet <BuildTarget>(buildPaths.Select(p => p.target));
var projects = new List <string>();
string convertError = null;
foreach (var file in Directory.GetFiles(projectsFolder))
{
if (Path.GetExtension(file).ToLower() != ".json")
{
continue;
}
var contents = PathVarRegex.Replace(File.ReadAllText(file), (match) => {
var platformName = match.Groups[1].Value.ToLower();
if (platformName == "project")
{
return(Path.GetDirectoryName(Application.dataPath));
}
else if (platformName == "projects")
{
return(Path.GetFullPath(projectsFolder));
}
BuildTarget target;
try {
target = (BuildTarget)System.Enum.Parse(typeof(BuildTarget), platformName, true);
} catch {
convertError = $"Invalid build target path variable '{platformName}' in project JSON: {file}";
return("");
}
if (!buildPaths.Any(p => p.target == target))
{
convertError = $"Build target '{platformName}' not part of given build profile(s) in project JSON: {file}";
return("");
}
targets.Remove(target);
var path = buildPaths.Where(p => p.target == target).Select(p => p.path).First();
path = OptionHelper.GetBuildBasePath(path);
return(Path.GetFullPath(path));
});
if (convertError != null)
{
break;
}
var targetPath = Path.Combine(tempDir, Path.GetFileName(file));
File.WriteAllText(targetPath, contents);
projects.Add(targetPath);
}
if (convertError != null)
{
throw new Exception($"GOGDistro: {convertError}");
}
if (targets.Count > 0)
{
Debug.LogWarning("GOGDistro: Not all build targets filled into variables. Left over: "
+ string.Join(", ", targets.Select(t => t.ToString()).ToArray()));
}
task.Report(0, targets.Count + 1);
// Notarize mac builds
if (macNotarization != null)
{
task.Report(0, description: "Notarizing macOS builds");
foreach (var path in buildPaths.Where(p => p.target == BuildTarget.StandaloneOSX))
{
await macNotarization.Notarize(path, task);
}
}
// Build
task.baseStep++;
foreach (var project in projects)
{
var args = string.Format(
"build-game '{0}' --username='******' --password='******' --version={3}",
Path.GetFullPath(project), gogLogin.User, gogLogin.GetPassword(keychainService),
string.IsNullOrEmpty(overrideVersion) ? Application.version : overrideVersion
);
if (!string.IsNullOrEmpty(ignoreList))
{
args += $" --ignore_list='{Path.GetFullPath(ignoreList)}'";
}
if (!string.IsNullOrEmpty(branch.User))
{
args += $" --branch='{branch.User}'";
var pwd = branch.GetPassword(branchKeychainService);
if (pwd != null)
{
args += $" --branch_password='******'";
}
}
task.Report(0, description: $"Uploading {Path.GetFileName(project)}");
await Execute(new ExecutionArgs(cmd, args), task);
task.baseStep++;
}
} finally {
// Always clean up temporary files
Directory.Delete(tempDir, true);
}
}
protected override async Task RunDistribute(IEnumerable <BuildPath> buildPaths, TaskToken task)
{
// Check SDK
var cmd = FindSteamCmd();
// Check User
if (string.IsNullOrEmpty(steamLogin.User))
{
throw new Exception("SteamDistro: No Steam user set.");
}
if (steamLogin.GetPassword(keychainService) == null)
{
throw new Exception("SteamDistro: No Steam password found in Keychain.");
}
// Check scripts
if (string.IsNullOrEmpty(scriptsFolder) || !Directory.Exists(scriptsFolder))
{
throw new Exception("SteamDistro: Path to scripts folder not set.");
}
if (string.IsNullOrEmpty(appScript))
{
throw new Exception("SteamDistro: Name of app script not set.");
}
var appScriptPath = Path.Combine(scriptsFolder, appScript);
if (!File.Exists(appScriptPath))
{
throw new Exception("SteamDistro: App script not found in scripts folder.");
}
// Process scripts
var tempDir = FileUtil.GetUniqueTempPathInProject();
try {
Directory.CreateDirectory(tempDir);
var targets = new HashSet <BuildTarget>(buildPaths.Select(p => p.target));
string convertError = null;
foreach (var file in Directory.GetFiles(scriptsFolder))
{
if (Path.GetExtension(file).ToLower() != ".vdf")
{
continue;
}
var contents = PathVarRegex.Replace(File.ReadAllText(file), (match) => {
var platformName = match.Groups[1].Value.ToLower();
if (platformName == "project")
{
return(Path.GetDirectoryName(Application.dataPath));
}
else if (platformName == "scripts")
{
return(Path.GetFullPath(scriptsFolder));
}
BuildTarget target;
try {
target = (BuildTarget)System.Enum.Parse(typeof(BuildTarget), platformName, true);
} catch {
convertError = $"SteamDistro: Invalid build target path variable '{platformName}' in VDF script: {file}";
return("");
}
if (!buildPaths.Any(p => p.target == target))
{
convertError = $"SteamDistro: Build target '{platformName}' not part of given build profile(s) in VDF script: {file}";
return("");
}
targets.Remove(target);
var path = buildPaths.Where(p => p.target == target).Select(p => p.path).First();
path = OptionHelper.GetBuildBasePath(path);
return(Path.GetFullPath(path));
});
if (convertError != null)
{
break;
}
var targetPath = Path.Combine(tempDir, Path.GetFileName(file));
File.WriteAllText(targetPath, contents);
}
if (convertError != null)
{
throw new Exception($"SteamDistro: {convertError}");
}
if (targets.Count > 0)
{
Debug.LogWarning("SteamDistro: Not all build targets filled into variables. Left over: "
+ string.Join(", ", targets.Select(t => t.ToString()).ToArray()));
}
// Notarize mac builds
if (macNotarization != null)
{
task.Report(0, description: "Notarizing macOS builds");
foreach (var path in buildPaths.Where(p => p.target == BuildTarget.StandaloneOSX))
{
await macNotarization.Notarize(path, task);
}
}
// Build
var scriptPath = Path.GetFullPath(Path.Combine(tempDir, appScript));
var args = string.Format(
"+login '{0}' '{1}' +run_app_build_http '{2}' +quit",
steamLogin.User, steamLogin.GetPassword(keychainService), scriptPath
);
await Execute(new ExecutionArgs(cmd, args) {
onOutput = (output) => {
if (output.Contains("Logged in OK"))
{
task.Report(0, description: "Logged in");
}
else if (output.Contains("Building depot"))
{
var match = BuildingDepotRegex.Match(output);
if (match.Success)
{
task.Report(0, description: $"Building depo {match.Groups[1].Value}");
}
}
else if (output.Contains(""))
{
var match = SuccessBuildIdRegex.Match(output);
if (match.Success)
{
Debug.Log("SteamDistro: Build uploaded, ID = " + match.Groups[1].Value);
}
}
}
}, task);
} finally {
// Always clean up temp files
Directory.Delete(tempDir, true);
}
}
