# Copyright (c) Microsoft Corporation.

# Licensed under the MIT License.

$Environment = Get-EnvironmentInformation

$RepoRoot = (Resolve-Path -Path "$PSScriptRoot/../..").Path

$packagingStrings = Import-PowerShellDataFile "$PSScriptRoot\packaging.strings.psd1"

Import-Module "$PSScriptRoot\..\Xml" -ErrorAction Stop -Force

$DebianDistributions = @("deb")

$RedhatFullDistributions = @("rh")

$RedhatFddDistributions = @("cm")

$RedhatDistributions = @()

$RedhatDistributions += $RedhatFullDistributions

$RedhatDistributions += $RedhatFddDistributions

$AllDistributions = @()

$AllDistributions += $DebianDistributions

$AllDistributions += $RedhatDistributions

$AllDistributions += 'macOs'

$script:netCoreRuntime = 'net9.0'

$script:iconFileName = "Powershell_black_64.png"

$script:iconPath = Join-Path -path $PSScriptRoot -ChildPath "../../assets/$iconFileName" -Resolve

class R2RVerification {

[ValidateSet('NoR2R','R2R','SdkOnly')]

[string]

$R2RState = 'R2R'

[System.Reflection.PortableExecutable.Machine]

$Architecture = [System.Reflection.PortableExecutable.Machine]::Amd64

[ValidateSet('Linux','Apple','Windows')]

[string]

$OperatingSystem = 'Windows'

}

function Start-PSPackage {

[CmdletBinding(DefaultParameterSetName='Version',SupportsShouldProcess=$true)]

param(

# PowerShell packages use Semantic Versioning https://semver.org/

[Parameter(ParameterSetName = "Version")]

[string]$Version,

[Parameter(ParameterSetName = "ReleaseTag")]

[ValidatePattern("^v\d+\.\d+\.\d+(-\w+(\.\d{1,2})?)?$")]

[ValidateNotNullOrEmpty()]

[string]$ReleaseTag,

# Package name

[ValidatePattern("^powershell")]

[string]$Name = "powershell",

# Ubuntu, CentOS, Fedora, macOS, and Windows packages are supported

[ValidateSet("msix", "deb", "osxpkg", "rpm", "rpm-fxdependent", "rpm-fxdependent-arm64", "msi", "zip", "zip-pdb", "tar", "tar-arm", "tar-arm64", "tar-alpine", "fxdependent", "fxdependent-win-desktop", "min-size", "tar-alpine-fxdependent")]

[string[]]$Type,

# Generate windows downlevel package

[ValidateSet("win7-x86", "win7-x64", "win-arm", "win-arm64")]

[string] $WindowsRuntime,

[ValidateSet('osx-x64', 'osx-arm64')]

[ValidateScript({$Environment.IsMacOS})]

[string] $MacOSRuntime,

[string] $PackageBinPath,

[switch] $Private,

[Switch] $Force,

[Switch] $SkipReleaseChecks,

[switch] $NoSudo,

[switch] $LTS

)

DynamicParam {

if ($Type -in ('zip', 'min-size') -or $Type -like 'fxdependent*') {

# Add a dynamic parameter '-IncludeSymbols' when the specified package type is 'zip' only.

# The '-IncludeSymbols' parameter can be used to indicate that the package should only contain powershell binaries and symbols.

$ParameterAttr = New-Object "System.Management.Automation.ParameterAttribute"

$Attributes = New-Object "System.Collections.ObjectModel.Collection``1[System.Attribute]"

$Attributes.Add($ParameterAttr) > $null

$Parameter = New-Object "System.Management.Automation.RuntimeDefinedParameter" -ArgumentList ("IncludeSymbols", [switch], $Attributes)

$Dict = New-Object "System.Management.Automation.RuntimeDefinedParameterDictionary"

$Dict.Add("IncludeSymbols", $Parameter) > $null

return $Dict

}

}

End {

$IncludeSymbols = $null

if ($PSBoundParameters.ContainsKey('IncludeSymbols')) {

Write-Log 'setting IncludeSymbols'

$IncludeSymbols = $PSBoundParameters['IncludeSymbols']

}

# Runtime and Configuration settings required by the package

($Runtime, $Configuration) = if ($WindowsRuntime) {

$WindowsRuntime, "Release"

} elseif ($MacOSRuntime) {

$MacOSRuntime, "Release"

} elseif ($Type.Count -eq 1 -and $Type[0] -eq "tar-alpine") {

New-PSOptions -Configuration "Release" -Runtime "linux-musl-x64" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

} elseif ($Type.Count -eq 1 -and $Type[0] -eq "tar-arm") {

New-PSOptions -Configuration "Release" -Runtime "Linux-ARM" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

} elseif ($Type.Count -eq 1 -and $Type[0] -eq "tar-arm64") {

if ($IsMacOS) {

New-PSOptions -Configuration "Release" -Runtime "osx-arm64" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

} else {

New-PSOptions -Configuration "Release" -Runtime "Linux-ARM64" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

}

} elseif ($Type.Count -eq 1 -and $Type[0] -eq "rpm-fxdependent") {

New-PSOptions -Configuration "Release" -Runtime 'fxdependent-linux-x64' -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

} elseif ($Type.Count -eq 1 -and $Type[0] -eq "rpm-fxdependent-arm64") {

New-PSOptions -Configuration "Release" -Runtime 'fxdependent-linux-arm64' -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

}

elseif ($Type.Count -eq 1 -and $Type[0] -eq "tar-alpine-fxdependent") {

New-PSOptions -Configuration "Release" -Runtime 'fxdependent-noopt-linux-musl-x64' -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

}

else {

New-PSOptions -Configuration "Release" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }

}

if ($Environment.IsWindows) {

# Runtime will be one of win7-x64, win7-x86, "win-arm" and "win-arm64" on Windows.

# Build the name suffix for universal win-plat packages.

switch ($Runtime) {

"win-arm64" { $NameSuffix = "win-arm64" }

default { $NameSuffix = $_ -replace 'win\d+', 'win' }

}

}

if ($Type -eq 'fxdependent') {

$NameSuffix = "win-fxdependent"

Write-Log "Packaging : '$Type'; Packaging Configuration: '$Configuration', Runtime: '$Runtime'"

} elseif ($Type -eq 'fxdependent-win-desktop') {

$NameSuffix = "win-fxdependentWinDesktop"

Write-Log "Packaging : '$Type'; Packaging Configuration: '$Configuration', Runtime: '$Runtime'"

} elseif ($MacOSRuntime) {

$NameSuffix = $MacOSRuntime

Write-Log "Packaging : '$Type'; Packaging Configuration: '$Configuration', Runtime: '$Runtime'"

} else {

Write-Log "Packaging RID: '$Runtime'; Packaging Configuration: '$Configuration'"

}

$Script:Options = Get-PSOptions

$actualParams = @()

$PSModuleRestoreCorrect = $false

# Require PSModuleRestore for packaging without symbols

# But Disallow it when packaging with symbols

if (!$IncludeSymbols.IsPresent -and $Script:Options.PSModuleRestore) {

$actualParams += '-PSModuleRestore'

$PSModuleRestoreCorrect = $true

}

elseif ($IncludeSymbols.IsPresent -and !$Script:Options.PSModuleRestore) {

$PSModuleRestoreCorrect = $true

}

else {

$actualParams += '-PSModuleRestore'

}

$precheckFailed = if ($Type -like 'fxdependent*' -or $Type -eq 'tar-alpine') {

## We do not check on runtime for framework dependent package.

-not $Script:Options -or ## Start-PSBuild hasn't been executed yet

-not $PSModuleRestoreCorrect -or ## Last build didn't specify '-PSModuleRestore' correctly

$Script:Options.Configuration -ne $Configuration -or ## Last build was with configuration other than 'Release'

$Script:Options.Framework -ne $script:netCoreRuntime ## Last build wasn't for CoreCLR

} else {

-not $Script:Options -or ## Start-PSBuild hasn't been executed yet

-not $PSModuleRestoreCorrect -or ## Last build didn't specify '-PSModuleRestore' correctly

$Script:Options.Runtime -ne $Runtime -or ## Last build wasn't for the required RID

$Script:Options.Configuration -ne $Configuration -or ## Last build was with configuration other than 'Release'

$Script:Options.Framework -ne $script:netCoreRuntime ## Last build wasn't for CoreCLR

}

# Make sure the most recent build satisfies the package requirement

if ($precheckFailed) {

# It's possible that the most recent build doesn't satisfy the package requirement but

# an earlier build does.

# It's also possible that the last build actually satisfies the package requirement but

# then `Start-PSPackage` runs from a new PS session or `build.psm1` was reloaded.

#

# In these cases, the user will be asked to build again even though it's technically not

# necessary. However, we want it that way -- being very explict when generating packages.

# This check serves as a simple gate to ensure that the user knows what he is doing, and

# also ensure `Start-PSPackage` does what the user asks/expects, because once packages

# are generated, it'll be hard to verify if they were built from the correct content.

Write-Warning -Message "Start-PSPackage: The build PreCheck has failed."

if (-not $Script:Options) {

Write-Warning -Message "Start-PSPackage: builid options variable is null indicating Start-PSBuild hasn't been run yet."

}

if (-not $PSModuleRestoreCorrect) {

Write-Warning -Message "Start-PSPackage: PSModuleRestoreCorrect variable is null indicating build -PSModuleRestore was not performed."

}

if ($Script:Options.Configuration -ne $Configuration) {

Write-Warning -Message "Start-PSPackage: Build configuration is incorrect: Expected: $Configuration Actual: $($Script:Options.Configuration)"

}

if ($Script:Options.Framework -ne $script:netCoreRuntime) {

Write-Warning -Message "Start-PSPackage: Build .NET version is incorrect: Expected: $($script:netCoreRuntime) Actual: $($Script:Options.Framework)"

}

if (($Type -notlike 'fxdependent*' -and $Type -ne 'tar-alpine') -and ($Script:Options.Runtime -ne $Runtime)) {

Write-Warning -Message "Start-PSPackage: Build RID does not match expected RID: Expected: $Runtime Actual: $($Script:Options.Runtime)"

}

$params = @('-Clean')

if (!$IncludeSymbols.IsPresent) {

$params += '-PSModuleRestore'

}

$actualParams += '-Runtime ' + $Script:Options.Runtime

if ($Type -eq 'fxdependent') {

$params += '-Runtime', 'fxdependent'

} elseif ($Type -eq 'fxdependent-win-desktop') {

$params += '-Runtime', 'fxdependent-win-desktop'

} else {

$params += '-Runtime', $Runtime

}

$params += '-Configuration', $Configuration

$actualParams += '-Configuration ' + $Script:Options.Configuration

Write-Warning "Build started with unexpected parameters 'Start-PSBuild $actualParams"

throw "Please ensure you have run 'Start-PSBuild $params'!"

}

if ($SkipReleaseChecks.IsPresent) {

Write-Warning "Skipping release checks."

}

elseif (!$Script:Options.RootInfo.IsValid){

throw $Script:Options.RootInfo.Warning

}

# If ReleaseTag is specified, use the given tag to calculate Version

if ($PSCmdlet.ParameterSetName -eq "ReleaseTag") {

$Version = $ReleaseTag -Replace '^v'

}

# Use Git tag if not given a version

if (-not $Version) {

$Version = (git --git-dir="$RepoRoot/.git" describe) -Replace '^v'

}

$Source = if ($PackageBinPath) {

$PackageBinPath

}

else {

Split-Path -Path $Script:Options.Output -Parent

}

Write-Verbose -Verbose "Source: $Source"

# Copy the ThirdPartyNotices.txt so it's part of the package

Copy-Item "$RepoRoot/ThirdPartyNotices.txt" -Destination $Source -Force

# Copy the default.help.txt so it's part of the package

Copy-Item "$RepoRoot/assets/default.help.txt" -Destination "$Source/en-US" -Force

if (-not $SkipGenerateReleaseFiles -and -not $env:TF_BUILD) {

# Make sure psoptions.json file exists so appropriate files.wsx is generated

$psOptionsPath = (Join-Path -Path $Source "psoptions.json")

if (-not (Test-Path -Path $psOptionsPath)) {

$createdOptionsFile = New-Item -Path $psOptionsPath -Force

Write-Verbose -Verbose "Created psoptions file: $createdOptionsFile"

}

# Make sure _manifest\spdx_2.2\manifest.spdx.json file exists so appropriate files.wxs is generated

$manifestSpdxPath = (Join-Path -Path $Source "_manifest\spdx_2.2\manifest.spdx.json")

if (-not (Test-Path -Path $manifestSpdxPath)) {

$createdSpdxPath = New-Item -Path $manifestSpdxPath -Force

Write-Verbose -Verbose "Created manifest.spdx.json file: $createdSpdxPath"

}

$manifestSpdxPathSha = (Join-Path -Path $Source "_manifest\spdx_2.2\manifest.spdx.json.sha256")

if (-not (Test-Path -Path $manifestSpdxPathSha)) {

$createdSpdxPathSha = New-Item -Path $manifestSpdxPathSha -Force

Write-Verbose -Verbose "Created manifest.spdx.json.sha256 file: $createdSpdxPathSha"

}

}

# If building a symbols package, we add a zip of the parent to publish

if ($IncludeSymbols.IsPresent)

{

$publishSource = $Source

$buildSource = Split-Path -Path $Source -Parent

$Source = New-TempFolder

$symbolsSource = New-TempFolder

try

{

# Copy files which go into the root package

Get-ChildItem -Path $publishSource | Copy-Item -Destination $Source -Recurse

$signingXml = [xml] (Get-Content (Join-Path $PSScriptRoot "..\releaseBuild\signing.xml" -Resolve))

# Only include the files we sign for compliance scanning, those are the files we build.

$filesToInclude = $signingXml.SignConfigXML.job.file.src | Where-Object { -not $_.endswith('pwsh.exe') -and ($_.endswith(".dll") -or $_.endswith(".exe")) } | ForEach-Object { ($_ -split '\\')[-1] }

$filesToInclude += $filesToInclude | ForEach-Object { $_ -replace '.dll', '.pdb' }

Get-ChildItem -Path $buildSource | Where-Object { $_.Name -in $filesToInclude } | Copy-Item -Destination $symbolsSource -Recurse

# Zip symbols.zip to the root package

$zipSource = Join-Path $symbolsSource -ChildPath '*'

$zipPath = Join-Path -Path $Source -ChildPath 'symbols.zip'

Save-PSOptions -PSOptionsPath (Join-Path -Path $source -ChildPath 'psoptions.json') -Options $Script:Options

Compress-Archive -Path $zipSource -DestinationPath $zipPath

}

finally

{

Remove-Item -Path $symbolsSource -Recurse -Force -ErrorAction SilentlyContinue

}

}

Write-Log "Packaging Source: '$Source'"

# Decide package output type

if (-not $Type) {

$Type = if ($Environment.IsLinux) {

if ($Environment.LinuxInfo.ID -match "ubuntu") {

"deb", "tar"

} elseif ($Environment.IsRedHatFamily) {

"rpm"

} elseif ($Environment.IsSUSEFamily) {

"rpm"

} else {

throw "Building packages for $($Environment.LinuxInfo.PRETTY_NAME) is unsupported!"

}

} elseif ($Environment.IsMacOS) {

"osxpkg", "tar"

} elseif ($Environment.IsWindows) {

"msi", "msix"

}

Write-Warning "-Type was not specified, continuing with $Type!"

}

Write-Log "Packaging Type: $Type"

# Add the symbols to the suffix

# if symbols are specified to be included

if ($IncludeSymbols.IsPresent -and $NameSuffix) {

$NameSuffix = "symbols-$NameSuffix"

}

elseif ($IncludeSymbols.IsPresent) {

$NameSuffix = "symbols"

}

switch ($Type) {

"zip" {

$os, $architecture = ($Script:Options.Runtime -split '-')

$peOS = ConvertTo-PEOperatingSystem -OperatingSystem $os

$peArch = ConvertTo-PEArchitecture -Architecture $architecture

$Arguments = @{

PackageNameSuffix = $NameSuffix

PackageSourcePath = $Source

PackageVersion = $Version

Force = $Force

}

if ($architecture -in 'x86', 'x64', 'arm', 'arm64') {

$Arguments += @{ R2RVerification = [R2RVerification]@{

R2RState = 'R2R'

OperatingSystem = $peOS

Architecture = $peArch

}

}

} else {

$Arguments += @{ R2RVerification = [R2RVerification]@{

R2RState = 'SdkOnly'

OperatingSystem = $peOS

Architecture = $peArch

}

}

}

if ($PSCmdlet.ShouldProcess("Create Zip Package")) {

New-ZipPackage @Arguments

}

}

"zip-pdb" {

$Arguments = @{

PackageNameSuffix = $NameSuffix

PackageSourcePath = $Source

PackageVersion = $Version

Force = $Force

}

if ($PSCmdlet.ShouldProcess("Create Symbols Zip Package")) {

New-PdbZipPackage @Arguments

}

}

"min-size" {

# Add suffix '-gc' because this package is for the Guest Config team.

if ($Environment.IsWindows) {

$Arguments = @{

PackageNameSuffix = "$NameSuffix-gc"

PackageSourcePath = $Source

PackageVersion = $Version

Force = $Force

R2RVerification = [R2RVerification]@{

R2RState = 'SdkOnly'

OperatingSystem = "Windows"

Architecture = "amd64"

}

}

if ($PSCmdlet.ShouldProcess("Create Zip Package")) {

New-ZipPackage @Arguments

}

}

elseif ($Environment.IsLinux) {

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

PackageNameSuffix = 'gc'

Version = $Version

Force = $Force

R2RVerification = [R2RVerification]@{

R2RState = 'SdkOnly'

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

}

{ $_ -like "fxdependent*"} {

if ($Environment.IsWindows) {

$Arguments = @{

PackageNameSuffix = $NameSuffix

PackageSourcePath = $Source

PackageVersion = $Version

Force = $Force

R2RVerification = [R2RVerification]@{

R2RState = 'NoR2R'

}

}

if ($PSCmdlet.ShouldProcess("Create Zip Package")) {

New-ZipPackage @Arguments

}

} elseif ($Environment.IsLinux) {

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

PackageNameSuffix = 'fxdependent'

Version = $Version

Force = $Force

R2RVerification = [R2RVerification]@{

R2RState = 'NoR2R'

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

}

"tar-alpine-fxdependent" {

if ($Environment.IsLinux) {

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

PackageNameSuffix = 'musl-noopt-fxdependent'

Version = $Version

Force = $Force

R2RVerification = [R2RVerification]@{

R2RState = 'NoR2R'

OperatingSystem = "Linux"

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

}

"msi" {

$TargetArchitecture = "x64"

$r2rArchitecture = "amd64"

if ($Runtime -match "-x86") {

$TargetArchitecture = "x86"

$r2rArchitecture = "i386"

}

elseif ($Runtime -match "-arm64")

{

$TargetArchitecture = "arm64"

$r2rArchitecture = "arm64"

}

Write-Verbose "TargetArchitecture = $TargetArchitecture" -Verbose

$Arguments = @{

ProductNameSuffix = $NameSuffix

ProductSourcePath = $Source

ProductVersion = $Version

AssetsPath = "$RepoRoot\assets"

ProductTargetArchitecture = $TargetArchitecture

Force = $Force

}

if ($PSCmdlet.ShouldProcess("Create MSI Package")) {

New-MSIPackage @Arguments

}

}

"msix" {

$Arguments = @{

ProductNameSuffix = $NameSuffix

ProductSourcePath = $Source

ProductVersion = $Version

Architecture = $WindowsRuntime.Split('-')[1]

Force = $Force

Private = $Private

}

if ($PSCmdlet.ShouldProcess("Create MSIX Package")) {

New-MSIXPackage @Arguments

}

}

"tar" {

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

}

if ($MacOSRuntime) {

$architecture = $MacOSRuntime.Split('-')[1]

$Arguments['Architecture'] = $architecture

}

if ($Script:Options.Runtime -match '(linux|osx).*') {

$os, $architecture = ($Script:Options.Runtime -split '-')

$peOS = ConvertTo-PEOperatingSystem -OperatingSystem $os

$peArch = ConvertTo-PEArchitecture -Architecture $architecture

$Arguments['R2RVerification'] = [R2RVerification]@{

R2RState = "R2R"

OperatingSystem = $peOS

Architecture = $peArch

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

"tar-arm" {

$peArch = ConvertTo-PEArchitecture -Architecture 'arm'

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

Architecture = "arm32"

ExcludeSymbolicLinks = $true

R2RVerification = [R2RVerification]@{

R2RState = 'R2R'

OperatingSystem = "Linux"

Architecture = $peArch

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

"tar-arm64" {

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

Architecture = "arm64"

ExcludeSymbolicLinks = $true

R2RVerification = [R2RVerification]@{

R2RState = 'R2R'

OperatingSystem = "Linux"

Architecture = "arm64"

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

"tar-alpine" {

$Arguments = @{

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

Architecture = "musl-x64"

ExcludeSymbolicLinks = $true

R2RVerification = [R2RVerification]@{

R2RState = 'R2R'

OperatingSystem = "Linux"

Architecture = "amd64"

}

}

if ($PSCmdlet.ShouldProcess("Create tar.gz Package")) {

New-TarballPackage @Arguments

}

}

'deb' {

$Arguments = @{

Type = 'deb'

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

NoSudo = $NoSudo

LTS = $LTS

HostArchitecture = "amd64"

}

foreach ($Distro in $Script:DebianDistributions) {

$Arguments["Distribution"] = $Distro

if ($PSCmdlet.ShouldProcess("Create DEB Package for $Distro")) {

New-UnixPackage @Arguments

}

}

}

'rpm' {

$Arguments = @{

Type = 'rpm'

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

NoSudo = $NoSudo

LTS = $LTS

HostArchitecture = "x86_64"

}

foreach ($Distro in $Script:RedhatFullDistributions) {

$Arguments["Distribution"] = $Distro

if ($PSCmdlet.ShouldProcess("Create RPM Package for $Distro")) {

Write-Verbose -Verbose "Creating RPM Package for $Distro"

New-UnixPackage @Arguments

}

}

}

'rpm-fxdependent' {

$Arguments = @{

Type = 'rpm'

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

NoSudo = $NoSudo

LTS = $LTS

HostArchitecture = "x86_64"

}

foreach ($Distro in $Script:RedhatFddDistributions) {

$Arguments["Distribution"] = $Distro

if ($PSCmdlet.ShouldProcess("Create RPM Package for $Distro")) {

Write-Verbose -Verbose "Creating RPM Package for $Distro"

New-UnixPackage @Arguments

}

}

}

'rpm-fxdependent-arm64' {

$Arguments = @{

Type = 'rpm'

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

NoSudo = $NoSudo

LTS = $LTS

HostArchitecture = "aarch64"

}

foreach ($Distro in $Script:RedhatFddDistributions) {

$Arguments["Distribution"] = $Distro

if ($PSCmdlet.ShouldProcess("Create RPM Package for $Distro")) {

Write-Verbose -Verbose "Creating RPM Package for $Distro"

New-UnixPackage @Arguments

}

}

}

'osxpkg' {

$HostArchitecture = "x86_64"

if ($MacOSRuntime -match "-arm64") {

$HostArchitecture = "arm64"

}

Write-Verbose "HostArchitecture = $HostArchitecture" -Verbose

$Arguments = @{

Type = 'osxpkg'

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

NoSudo = $NoSudo

LTS = $LTS

HostArchitecture = $HostArchitecture

}

if ($PSCmdlet.ShouldProcess("Create macOS Package")) {

New-UnixPackage @Arguments

}

}

default {

$Arguments = @{

Type = $_

PackageSourcePath = $Source

Name = $Name

Version = $Version

Force = $Force

NoSudo = $NoSudo

LTS = $LTS

HostArchitecture = "all"

}

if ($PSCmdlet.ShouldProcess("Create $_ Package")) {

New-UnixPackage @Arguments

}

}

}

if ($IncludeSymbols.IsPresent)

{

# Source is a temporary folder when -IncludeSymbols is present. So, we should remove it.

Remove-Item -Path $Source -Recurse -Force -ErrorAction SilentlyContinue

}

}

}

function New-TarballPackage {

[CmdletBinding(SupportsShouldProcess=$true)]

param (

[Parameter(Mandatory)]

[string] $PackageSourcePath,

# Must start with 'powershell' but may have any suffix

[Parameter(Mandatory)]

[ValidatePattern("^powershell")]

[string] $Name,

# Suffix of the Name

[string] $PackageNameSuffix,

[Parameter(Mandatory)]

[string] $Version,

[Parameter()]

[string] $Architecture = "x64",

[switch] $Force,

[switch] $ExcludeSymbolicLinks,

[string] $CurrentLocation = (Get-Location),

[R2RVerification] $R2RVerification

)

if ($PackageNameSuffix) {

$packageName = "$Name-$Version-{0}-$Architecture-$PackageNameSuffix.tar.gz"

} else {

$packageName = "$Name-$Version-{0}-$Architecture.tar.gz"

}

if ($Environment.IsWindows) {

throw "Must be on Linux or macOS to build 'tar.gz' packages!"

} elseif ($Environment.IsLinux) {

$packageName = $packageName -f "linux"

} elseif ($Environment.IsMacOS) {

$packageName = $packageName -f "osx"

}

$packagePath = Join-Path -Path $CurrentLocation -ChildPath $packageName

Write-Verbose "Create package $packageName"

Write-Verbose "Package destination path: $packagePath"

if (Test-Path -Path $packagePath) {

if ($Force -or $PSCmdlet.ShouldProcess("Overwrite existing package file")) {

Write-Verbose "Overwrite existing package file at $packagePath" -Verbose

Remove-Item -Path $packagePath -Force -ErrorAction Stop -Confirm:$false

}

}

$Staging = "$PSScriptRoot/staging"

New-StagingFolder -StagingPath $Staging -PackageSourcePath $PackageSourcePath -R2RVerification $R2RVerification

if (Get-Command -Name tar -CommandType Application -ErrorAction Ignore) {

if ($Force -or $PSCmdlet.ShouldProcess("Create tarball package")) {

$options = "-czf"

if ($PSBoundParameters.ContainsKey('Verbose') -and $PSBoundParameters['Verbose'].IsPresent) {

# Use the verbose mode '-v' if '-Verbose' is specified

$options = "-czvf"

}

try {

Push-Location -Path $Staging

tar $options $packagePath *

} finally {

Pop-Location

}

if (Test-Path -Path $packagePath) {

Write-Log "You can find the tarball package at $packagePath"

return (Get-Item $packagePath)

} else {

throw "Failed to create $packageName"

}

}

} else {

throw "Failed to create the package because the application 'tar' cannot be found"

}

}

function New-TempFolder

{

$tempPath = [System.IO.Path]::GetTempPath()

$tempFolder = Join-Path -Path $tempPath -ChildPath ([System.IO.Path]::GetRandomFileName())

if (!(Test-Path -Path $tempFolder))

{

$null = New-Item -Path $tempFolder -ItemType Directory

}

return $tempFolder

}

function New-PSSignedBuildZip

{

param(

[Parameter(Mandatory)]

[string]$BuildPath,

[Parameter(Mandatory)]

[string]$SignedFilesPath,

[Parameter(Mandatory)]

[string]$DestinationFolder,

[parameter(HelpMessage='VSTS variable to set for path to zip')]

[string]$VstsVariableName

)

Update-PSSignedBuildFolder -BuildPath $BuildPath -SignedFilesPath $SignedFilesPath

# Remove '$signedFilesPath' now that signed binaries are copied

if (Test-Path $signedFilesPath)

{

Remove-Item -Recurse -Force -Path $signedFilesPath

}

New-PSBuildZip -BuildPath $BuildPath -DestinationFolder $DestinationFolder -VstsVariableName $VstsVariableName

}

function New-PSBuildZip

{

param(

[Parameter(Mandatory)]

[string]$BuildPath,

[Parameter(Mandatory)]

[string]$DestinationFolder,

[parameter(HelpMessage='VSTS variable to set for path to zip')]

[string]$VstsVariableName

)

$name = Split-Path -Path $BuildPath -Leaf

$zipLocationPath = Join-Path -Path $DestinationFolder -ChildPath "$name-signed.zip"

Compress-Archive -Path $BuildPath\* -DestinationPath $zipLocationPath

if ($VstsVariableName)

{

# set VSTS variable with path to package files

Write-Log "Setting $VstsVariableName to $zipLocationPath"

Write-Host "##vso[task.setvariable variable=$VstsVariableName]$zipLocationPath"

}

else

{

return $zipLocationPath

}

}

function Update-PSSignedBuildFolder

{

param(

[Parameter(Mandatory)]

[string]$BuildPath,

[Parameter(Mandatory)]

[string]$SignedFilesPath,

[string[]] $RemoveFilter = ('*.pdb', '*.zip', '*.r2rmap')

)

$BuildPathNormalized = (Get-Item $BuildPath).FullName

$SignedFilesPathNormalized = (Get-Item $SignedFilesPath).FullName

Write-Verbose -Verbose "BuildPath = $BuildPathNormalized"

Write-Verbose -Verbose "SignedFilesPath = $signedFilesPath"

# Replace unsigned binaries with signed

$signedFilesFilter = Join-Path -Path $SignedFilesPathNormalized -ChildPath '*'

Write-Verbose -Verbose "signedFilesFilter = $signedFilesFilter"

$signedFilesList = Get-ChildItem -Path $signedFilesFilter -Recurse -File

foreach ($signedFileObject in $signedFilesList) {

# completely skip replacing pwsh on non-windows systems (there is no .exe extension here)

# and it may not be signed correctly

# The Shim will not be signed in CI.

if ($signedFileObject.Name -eq "pwsh" -or ($signedFileObject.Name -eq "Microsoft.PowerShell.GlobalTool.Shim.exe" -and $env:BUILD_REASON -eq 'PullRequest')) {

Write-Verbose -Verbose "Skipping $signedFileObject"

continue

}

$signedFilePath = $signedFileObject.FullName

Write-Verbose -Verbose "Processing $signedFilePath"

# Agents seems to be on a case sensitive file system

if ($IsLinux) {

$relativePath = $signedFilePath.Replace($SignedFilesPathNormalized, '')

} else {

$relativePath = $signedFilePath.ToLowerInvariant().Replace($SignedFilesPathNormalized.ToLowerInvariant(), '')

}

Write-Verbose -Verbose "relativePath = $relativePath"

$destination = (Get-Item (Join-Path -Path $BuildPathNormalized -ChildPath $relativePath)).FullName

Write-Verbose -Verbose "destination = $destination"

Write-Log "replacing $destination with $signedFilePath"

if (-not (Test-Path $destination)) {

$parent = Split-Path -Path $destination -Parent

$exists = Test-Path -Path $parent

if ($exists) {

Write-Verbose -Verbose "Parent:"

Get-ChildItem -Path $parent | Select-Object -ExpandProperty FullName | Write-Verbose -Verbose

}

Write-Error "File not found: $destination, parent - $parent exists: $exists"

}

# Get-AuthenticodeSignature will only work on Windows

if ($IsWindows)

{

$signature = Get-AuthenticodeSignature -FilePath $signedFilePath

if ($signature.Status -ne 'Valid') {

Write-Error "Invalid signature for $signedFilePath"

}

}

else

{

Write-Verbose -Verbose "Skipping certificate check of $signedFilePath on non-Windows"

}

Copy-Item -Path $signedFilePath -Destination $destination -Force

}

foreach($filter in $RemoveFilter) {

$removePath = Join-Path -Path $BuildPathNormalized -ChildPath $filter

Remove-Item -Path $removePath -Recurse -Force

}

}

function Expand-PSSignedBuild

{

param(

[Parameter(Mandatory)]

[string]$BuildZip,

[Switch]$SkipPwshExeCheck

)

$psModulePath = Split-Path -Path $PSScriptRoot

# Expand signed build

$buildPath = Join-Path -Path $psModulePath -ChildPath 'ExpandedBuild'

$null = New-Item -Path $buildPath -ItemType Directory -Force

Expand-Archive -Path $BuildZip -DestinationPath $buildPath -Force

# Remove the zip file that contains only those files from the parent folder of 'publish'.

# That zip file is used for compliance scan.

Remove-Item -Path (Join-Path -Path $buildPath -ChildPath '*.zip') -Recurse

if ($SkipPwshExeCheck) {

$executablePath = (Join-Path $buildPath -ChildPath 'pwsh.dll')

} else {

if ($IsMacOS -or $IsLinux) {

$executablePath = (Join-Path $buildPath -ChildPath 'pwsh')

} else {

$executablePath = (Join-Path $buildPath -ChildPath 'pwsh.exe')

}

}

Restore-PSModuleToBuild -PublishPath $buildPath

$psOptionsPath = Join-Path $buildPath -ChildPath 'psoptions.json'

Restore-PSOptions -PSOptionsPath $psOptionsPath

$options = Get-PSOptions