345 lines
17 KiB
PowerShell
345 lines
17 KiB
PowerShell
[CmdletBinding()]
|
|
param(
|
|
[switch]$SkipExecution
|
|
)
|
|
|
|
Set-StrictMode -Version Latest
|
|
$ErrorActionPreference = 'Stop'
|
|
|
|
function Fail([string]$Message) {
|
|
Write-Host "::error::$Message"
|
|
if ($SkipExecution) {
|
|
throw $Message
|
|
}
|
|
exit 1
|
|
}
|
|
|
|
function Require-Environment([string]$Name) {
|
|
$value = [Environment]::GetEnvironmentVariable($Name)
|
|
if ([string]::IsNullOrWhiteSpace($value)) {
|
|
Fail "Required environment variable '$Name' is not set."
|
|
}
|
|
return $value
|
|
}
|
|
|
|
function Test-PathIsWithinDirectory([string]$ParentDirectory, [string]$CandidateDirectory) {
|
|
$parentPath = [IO.Path]::GetFullPath($ParentDirectory)
|
|
$candidatePath = [IO.Path]::GetFullPath($CandidateDirectory)
|
|
$separator = [IO.Path]::DirectorySeparatorChar.ToString()
|
|
|
|
if ($candidatePath.Equals($parentPath, [StringComparison]::OrdinalIgnoreCase)) {
|
|
return $true
|
|
}
|
|
|
|
if (-not $parentPath.EndsWith($separator)) {
|
|
$parentPath += $separator
|
|
}
|
|
|
|
return $candidatePath.StartsWith($parentPath, [StringComparison]::OrdinalIgnoreCase)
|
|
}
|
|
|
|
function Get-ActualArchitecture {
|
|
$architecture = $env:PROCESSOR_ARCHITEW6432
|
|
if ([string]::IsNullOrWhiteSpace($architecture)) {
|
|
$architecture = $env:PROCESSOR_ARCHITECTURE
|
|
}
|
|
|
|
switch ($architecture.ToUpperInvariant()) {
|
|
'AMD64' { return 'x86_64' }
|
|
'X86' { return 'x86_32' }
|
|
'ARM64' { return 'arm64' }
|
|
default { Fail "Unsupported Windows runner architecture: $architecture." }
|
|
}
|
|
}
|
|
|
|
function Get-GodotAssets([string]$Version, [string]$Dotnet, [string]$Architecture) {
|
|
if ($Dotnet -eq 'true') {
|
|
$edition = 'dotnet'
|
|
$editorBaseName = switch ($Architecture) {
|
|
'x86_32' { "Godot_v${Version}_mono_win32" }
|
|
'x86_64' { "Godot_v${Version}_mono_win64" }
|
|
'arm64' { "Godot_v${Version}_mono_windows_arm64" }
|
|
default { Fail "Unsupported Windows host-arch '$Architecture'." }
|
|
}
|
|
|
|
return [PSCustomObject]@{
|
|
Edition = $edition
|
|
EditorAsset = "$editorBaseName.zip"
|
|
EditorFileName = "${editorBaseName}_console.exe"
|
|
TemplatesAsset = "Godot_v${Version}_mono_export_templates.tpz"
|
|
TemplateVersion = ($Version -replace '-', '.') + '.mono'
|
|
}
|
|
}
|
|
|
|
$edition = 'standard'
|
|
$editorBaseName = switch ($Architecture) {
|
|
'x86_32' { "Godot_v${Version}_win32" }
|
|
'x86_64' { "Godot_v${Version}_win64" }
|
|
'arm64' { "Godot_v${Version}_windows_arm64" }
|
|
default { Fail "Unsupported Windows host-arch '$Architecture'." }
|
|
}
|
|
|
|
return [PSCustomObject]@{
|
|
Edition = $edition
|
|
EditorAsset = "${editorBaseName}.exe.zip"
|
|
EditorFileName = "${editorBaseName}_console.exe"
|
|
TemplatesAsset = "Godot_v${Version}_export_templates.tpz"
|
|
TemplateVersion = $Version -replace '-', '.'
|
|
}
|
|
}
|
|
|
|
function Get-ExpectedPeMachine([string]$Architecture) {
|
|
switch ($Architecture) {
|
|
'x86_32' { return [uint16]0x014c }
|
|
'x86_64' { return [uint16]0x8664 }
|
|
'arm64' { return [uint16]0xaa64 }
|
|
default { Fail "Unsupported Windows host-arch '$Architecture'." }
|
|
}
|
|
}
|
|
|
|
function Get-Checksum([string]$ManifestPath, [string]$Asset, [string]$Version, [string]$Edition, [string]$Architecture, [string]$BaseUrl) {
|
|
foreach ($line in Get-Content -LiteralPath $ManifestPath) {
|
|
if ($line -match '^([0-9A-Fa-f]{128})\s+\*?(.+)$' -and $Matches[2] -eq $Asset) {
|
|
return $Matches[1].ToLowerInvariant()
|
|
}
|
|
}
|
|
|
|
Fail "Godot $Version does not publish required $Edition asset '$Asset' for Windows/$Architecture at $BaseUrl. Choose a supported stable release and architecture."
|
|
}
|
|
|
|
function Invoke-Download([string]$Uri, [string]$Destination) {
|
|
$lastError = $null
|
|
for ($attempt = 1; $attempt -le 3; $attempt++) {
|
|
try {
|
|
Invoke-WebRequest -UseBasicParsing -Uri $Uri -OutFile $Destination
|
|
$lastError = $null
|
|
break
|
|
} catch {
|
|
$lastError = $_
|
|
if (Test-Path -LiteralPath $Destination) {
|
|
Remove-Item -LiteralPath $Destination -Force
|
|
}
|
|
if ($attempt -lt 3) {
|
|
Start-Sleep -Seconds $attempt
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($null -ne $lastError) {
|
|
Fail "Failed to download '$Uri' after 3 attempts: $($lastError.Exception.Message)"
|
|
}
|
|
}
|
|
|
|
function Invoke-VerifiedDownload([string]$Uri, [string]$Destination, [string]$ExpectedChecksum) {
|
|
Invoke-Download $Uri $Destination
|
|
$actualChecksum = (Get-FileHash -LiteralPath $Destination -Algorithm SHA512).Hash.ToLowerInvariant()
|
|
if ($actualChecksum -ne $ExpectedChecksum) {
|
|
Fail "SHA-512 verification failed for $(Split-Path -Leaf $Destination)."
|
|
}
|
|
}
|
|
|
|
function Get-CachePaths([string]$Root, [string]$TemplateVersion) {
|
|
$editorDirectory = Join-Path $Root 'editor'
|
|
$userHome = Join-Path $Root 'home'
|
|
return [PSCustomObject]@{
|
|
Root = $Root
|
|
EditorDirectory = $editorDirectory
|
|
UserHome = $userHome
|
|
TemplateDirectory = Join-Path $userHome "AppData\Roaming\Godot\export_templates\$TemplateVersion"
|
|
Marker = Join-Path $Root '.complete'
|
|
}
|
|
}
|
|
|
|
function Get-EditorExecutable([string]$EditorDirectory, [string]$ExpectedFileName) {
|
|
$matches = @(Get-ChildItem -LiteralPath $EditorDirectory -Recurse -File -ErrorAction SilentlyContinue |
|
|
Where-Object { $_.Name -eq $ExpectedFileName })
|
|
if ($matches.Count -eq 1) {
|
|
return $matches[0].FullName
|
|
}
|
|
return $null
|
|
}
|
|
|
|
function Get-PeMachine([string]$Path) {
|
|
try {
|
|
$stream = [IO.File]::Open($Path, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::Read)
|
|
try {
|
|
if ($stream.Length -lt 64) { return $null }
|
|
$header = New-Object byte[] 64
|
|
if ($stream.Read($header, 0, $header.Length) -ne $header.Length -or $header[0] -ne 0x4d -or $header[1] -ne 0x5a) {
|
|
return $null
|
|
}
|
|
|
|
$peOffset = [BitConverter]::ToInt32($header, 0x3c)
|
|
if ($peOffset -lt 0 -or ($peOffset + 6) -gt $stream.Length) { return $null }
|
|
$stream.Position = $peOffset
|
|
$signature = New-Object byte[] 6
|
|
if ($stream.Read($signature, 0, $signature.Length) -ne $signature.Length) { return $null }
|
|
if ($signature[0] -ne 0x50 -or $signature[1] -ne 0x45 -or $signature[2] -ne 0 -or $signature[3] -ne 0) { return $null }
|
|
return [BitConverter]::ToUInt16($signature, 4)
|
|
} finally {
|
|
$stream.Dispose()
|
|
}
|
|
} catch {
|
|
return $null
|
|
}
|
|
}
|
|
|
|
function Test-ExpectedEditor([string]$EditorDirectory, [string]$ExpectedFileName, [uint16]$ExpectedMachine) {
|
|
$editorExecutable = Get-EditorExecutable $EditorDirectory $ExpectedFileName
|
|
return $null -ne $editorExecutable -and (Get-PeMachine $editorExecutable) -eq $ExpectedMachine
|
|
}
|
|
|
|
function Assert-ExpectedEditor([string]$EditorDirectory, [string]$ExpectedFileName, [uint16]$ExpectedMachine, [string]$Architecture) {
|
|
$editorExecutable = Get-EditorExecutable $EditorDirectory $ExpectedFileName
|
|
if ($null -eq $editorExecutable) {
|
|
Fail "The Godot editor archive did not contain the expected console executable '$ExpectedFileName'."
|
|
}
|
|
if ((Get-PeMachine $editorExecutable) -ne $ExpectedMachine) {
|
|
Fail "The expected Godot console executable '$ExpectedFileName' is not a valid $Architecture Windows executable."
|
|
}
|
|
return $editorExecutable
|
|
}
|
|
|
|
function Test-ValidCache($Paths, [string]$TemplateVersion, [string]$ExpectedFileName, [uint16]$ExpectedMachine) {
|
|
if (-not (Test-Path -LiteralPath $Paths.Marker -PathType Leaf)) { return $false }
|
|
$installedVersion = Join-Path $Paths.TemplateDirectory 'version.txt'
|
|
if (-not (Test-Path -LiteralPath $installedVersion -PathType Leaf)) { return $false }
|
|
if ((Get-Content -LiteralPath $installedVersion -Raw).Trim() -ne $TemplateVersion) { return $false }
|
|
return Test-ExpectedEditor $Paths.EditorDirectory $ExpectedFileName $ExpectedMachine
|
|
}
|
|
|
|
function Install-ExportTemplates($Paths, [string]$StagingDirectory, [string]$TemplateAsset, [string]$TemplateVersion) {
|
|
$stagedTemplates = Join-Path $StagingDirectory 'templates'
|
|
$stagedVersion = Join-Path $stagedTemplates 'version.txt'
|
|
if (-not (Test-Path -LiteralPath $stagedVersion -PathType Leaf)) {
|
|
Fail "The export-template archive '$TemplateAsset' did not contain templates/version.txt."
|
|
}
|
|
if ((Get-Content -LiteralPath $stagedVersion -Raw).Trim() -ne $TemplateVersion) {
|
|
Fail "The export-template archive '$TemplateAsset' reports template version '$((Get-Content -LiteralPath $stagedVersion -Raw).Trim())', expected '$TemplateVersion'."
|
|
}
|
|
|
|
New-Item -ItemType Directory -Force -Path $Paths.TemplateDirectory | Out-Null
|
|
Get-ChildItem -LiteralPath $stagedTemplates -Force | Copy-Item -Destination $Paths.TemplateDirectory -Recurse -Force
|
|
if (-not (Test-Path -LiteralPath (Join-Path $Paths.TemplateDirectory 'version.txt') -PathType Leaf)) {
|
|
Fail "The export-template archive '$TemplateAsset' could not be installed to '$($Paths.TemplateDirectory)'."
|
|
}
|
|
}
|
|
|
|
function Install-GodotCache($Paths, $Assets, [uint16]$ExpectedMachine, [string]$Architecture, [string]$Version, [string]$BaseUrl) {
|
|
New-Item -ItemType Directory -Force -Path $Paths.EditorDirectory | Out-Null
|
|
$manifestPath = Join-Path $Paths.Root 'SHA512-SUMS.txt'
|
|
$editorArchive = Join-Path $Paths.Root $Assets.EditorAsset
|
|
$templatesArchive = Join-Path $Paths.Root $Assets.TemplatesAsset
|
|
$templatesZipArchive = Join-Path $Paths.Root 'export-templates.zip'
|
|
$templatesStagingDirectory = Join-Path $Paths.Root 'templates-staging'
|
|
|
|
Invoke-Download "$BaseUrl/SHA512-SUMS.txt" $manifestPath
|
|
$editorChecksum = Get-Checksum $manifestPath $Assets.EditorAsset $Version $Assets.Edition $Architecture $BaseUrl
|
|
$templatesChecksum = Get-Checksum $manifestPath $Assets.TemplatesAsset $Version $Assets.Edition $Architecture $BaseUrl
|
|
Invoke-VerifiedDownload "$BaseUrl/$($Assets.EditorAsset)" $editorArchive $editorChecksum
|
|
Invoke-VerifiedDownload "$BaseUrl/$($Assets.TemplatesAsset)" $templatesArchive $templatesChecksum
|
|
|
|
Expand-Archive -LiteralPath $editorArchive -DestinationPath $Paths.EditorDirectory -Force
|
|
Assert-ExpectedEditor $Paths.EditorDirectory $Assets.EditorFileName $ExpectedMachine $Architecture | Out-Null
|
|
|
|
# Expand-Archive recognizes .zip only; Godot's verified .tpz payload is a ZIP archive.
|
|
Copy-Item -LiteralPath $templatesArchive -Destination $templatesZipArchive -Force
|
|
Expand-Archive -LiteralPath $templatesZipArchive -DestinationPath $templatesStagingDirectory -Force
|
|
Install-ExportTemplates $Paths $templatesStagingDirectory $Assets.TemplatesAsset $Assets.TemplateVersion
|
|
Remove-Item -LiteralPath $templatesStagingDirectory -Recurse -Force
|
|
|
|
@("release=$Version", "editor=$($Assets.EditorAsset)", "templates=$($Assets.TemplatesAsset)") |
|
|
Set-Content -LiteralPath $Paths.Marker -NoNewline -Encoding ASCII
|
|
}
|
|
|
|
function Invoke-GodotExport([string]$EditorExecutable, [string]$ProjectDirectory, [string]$ExportMode, [string]$ExportPreset, [string]$OutputFile, [scriptblock]$EditorRunner) {
|
|
try {
|
|
if ($null -ne $EditorRunner) {
|
|
& $EditorRunner $EditorExecutable $ProjectDirectory $ExportMode $ExportPreset $OutputFile
|
|
} else {
|
|
& $EditorExecutable --headless --path $ProjectDirectory "--export-$ExportMode" $ExportPreset $OutputFile
|
|
}
|
|
} catch {
|
|
Fail "Godot could not start '$EditorExecutable': $($_.Exception.Message)"
|
|
}
|
|
|
|
if ($LASTEXITCODE -ne 0) {
|
|
Fail "Godot export failed with exit code $LASTEXITCODE."
|
|
}
|
|
if (-not (Test-Path -LiteralPath $OutputFile -PathType Leaf)) {
|
|
Fail "Godot completed without creating the expected output '$(Split-Path -Leaf $OutputFile)'."
|
|
}
|
|
}
|
|
|
|
if ($SkipExecution) { return }
|
|
|
|
$GodotVersion = Require-Environment 'GODOT_VERSION'
|
|
$HostOs = Require-Environment 'GODOT_HOST_OS'
|
|
$HostArch = Require-Environment 'GODOT_HOST_ARCH'
|
|
$Dotnet = Require-Environment 'GODOT_DOTNET'
|
|
$ProjectPath = Require-Environment 'GODOT_PROJECT_PATH'
|
|
$ExportPreset = Require-Environment 'GODOT_EXPORT_PRESET'
|
|
$ExportMode = Require-Environment 'GODOT_EXPORT_MODE'
|
|
$ExportFileName = Require-Environment 'GODOT_EXPORT_FILE_NAME'
|
|
$ActionRoot = Require-Environment 'GODOT_ACTION_ROOT'
|
|
$Workspace = Require-Environment 'GITHUB_WORKSPACE'
|
|
$GithubOutput = Require-Environment 'GITHUB_OUTPUT'
|
|
|
|
if ($GodotVersion -notmatch '^4(\.[0-9]+){1,2}-stable$') { Fail 'godot-version must be a stable Godot 4 tag such as 4.7.2-stable. Alpha, beta, RC, and dev tags are not supported.' }
|
|
if ($HostOs -ne 'windows') { Fail "host-os must be 'windows' when this action runs on Windows." }
|
|
if ($Dotnet -notin @('true', 'false')) { Fail "dotnet must be 'true' or 'false'." }
|
|
if ($ExportMode -notin @('release', 'debug')) { Fail "export-mode must be 'release' or 'debug'." }
|
|
if ([string]::IsNullOrWhiteSpace($ExportPreset)) { Fail 'export-preset must not be empty.' }
|
|
if ([string]::IsNullOrWhiteSpace($ExportFileName) -or $ExportFileName -in @('.', '..') -or $ExportFileName.IndexOfAny([IO.Path]::GetInvalidFileNameChars()) -ge 0 -or $ExportFileName.Contains('/') -or $ExportFileName.Contains('\')) { Fail 'export-file-name must be a filename without path separators.' }
|
|
if ($HostArch -notin @('x86_32', 'x86_64', 'arm64')) { Fail "Unsupported Windows host-arch '$HostArch'." }
|
|
|
|
$actualArchitecture = Get-ActualArchitecture
|
|
if ($HostArch -ne $actualArchitecture) { Fail "host-arch '$HostArch' does not match this Windows runner ($actualArchitecture)." }
|
|
|
|
$workspaceDirectory = [IO.Path]::GetFullPath($Workspace)
|
|
if ([IO.Path]::IsPathRooted($ProjectPath)) { Fail 'project-path must be relative to the checked-out workspace.' }
|
|
$ProjectDirectory = [IO.Path]::GetFullPath((Join-Path $workspaceDirectory $ProjectPath))
|
|
if (-not (Test-PathIsWithinDirectory $workspaceDirectory $ProjectDirectory)) { Fail 'project-path must remain inside the checked-out workspace.' }
|
|
if (-not (Test-Path -LiteralPath $ProjectDirectory -PathType Container)) { Fail "project-path '$ProjectPath' does not exist." }
|
|
if (-not (Test-Path -LiteralPath (Join-Path $ProjectDirectory 'project.godot') -PathType Leaf)) { Fail "No project.godot was found in project-path '$ProjectPath'." }
|
|
$presetFile = Join-Path $ProjectDirectory 'export_presets.cfg'
|
|
if (-not (Test-Path -LiteralPath $presetFile -PathType Leaf)) { Fail "No export_presets.cfg was found in project-path '$ProjectPath'." }
|
|
if (-not (Select-String -LiteralPath $presetFile -SimpleMatch "name=`"$ExportPreset`"" -Quiet)) { Fail "Export preset '$ExportPreset' was not found in export_presets.cfg." }
|
|
|
|
$assets = Get-GodotAssets $GodotVersion $Dotnet $HostArch
|
|
$expectedMachine = Get-ExpectedPeMachine $HostArch
|
|
$baseUrl = "https://github.com/godotengine/godot/releases/download/$GodotVersion"
|
|
$cacheDirectory = Join-Path $ActionRoot "cache\$GodotVersion\$($assets.Edition)\windows-$HostArch"
|
|
$cachePaths = Get-CachePaths $cacheDirectory $assets.TemplateVersion
|
|
|
|
if (-not (Test-ValidCache $cachePaths $assets.TemplateVersion $assets.EditorFileName $expectedMachine)) {
|
|
$cacheParent = Split-Path -Parent $cacheDirectory
|
|
$stagingDirectory = Join-Path $cacheParent ((Split-Path -Leaf $cacheDirectory) + ".staging-$PID")
|
|
if (Test-Path -LiteralPath $stagingDirectory) { Remove-Item -LiteralPath $stagingDirectory -Recurse -Force }
|
|
New-Item -ItemType Directory -Force -Path $cacheParent | Out-Null
|
|
|
|
try {
|
|
$stagingPaths = Get-CachePaths $stagingDirectory $assets.TemplateVersion
|
|
Install-GodotCache $stagingPaths $assets $expectedMachine $HostArch $GodotVersion $baseUrl
|
|
if (-not (Test-ValidCache $stagingPaths $assets.TemplateVersion $assets.EditorFileName $expectedMachine)) { Fail 'Godot cache installation did not pass validation.' }
|
|
if (Test-Path -LiteralPath $cacheDirectory) { Remove-Item -LiteralPath $cacheDirectory -Recurse -Force }
|
|
Move-Item -LiteralPath $stagingDirectory -Destination $cacheDirectory
|
|
} finally {
|
|
if (Test-Path -LiteralPath $stagingDirectory) { Remove-Item -LiteralPath $stagingDirectory -Recurse -Force }
|
|
}
|
|
}
|
|
|
|
$editorExecutable = Assert-ExpectedEditor $cachePaths.EditorDirectory $assets.EditorFileName $expectedMachine $HostArch
|
|
$safePreset = ($ExportPreset -replace '[^A-Za-z0-9_.-]', '_').Trim('_')
|
|
if ([string]::IsNullOrWhiteSpace($safePreset)) { $safePreset = 'export' }
|
|
$buildDirectory = Join-Path $ActionRoot "builds\$safePreset-$ExportMode-$PID"
|
|
$outputFile = Join-Path $buildDirectory $ExportFileName
|
|
New-Item -ItemType Directory -Force -Path $buildDirectory | Out-Null
|
|
|
|
$env:USERPROFILE = $cachePaths.UserHome
|
|
$env:APPDATA = Join-Path $cachePaths.UserHome 'AppData\Roaming'
|
|
$env:LOCALAPPDATA = Join-Path $cachePaths.UserHome 'AppData\Local'
|
|
Invoke-GodotExport $editorExecutable $ProjectDirectory $ExportMode $ExportPreset $outputFile $null
|
|
|
|
"build-directory=$buildDirectory" | Add-Content -LiteralPath $GithubOutput -Encoding ASCII
|