# Copyright (c) Microsoft Corporation.

# Licensed under the MIT License.

param(

# Skips a check that prevents building PowerShell on unsupported Linux distributions

[parameter(Mandatory = $false)][switch]$SkipLinuxDistroCheck = $false

)

Set-StrictMode -Version 3.0

# On Unix paths is separated by colon

# On Windows paths is separated by semicolon

$script:TestModulePathSeparator = [System.IO.Path]::PathSeparator

$script:Options = $null

$dotnetCLIChannel = $(Get-Content $PSScriptRoot/DotnetRuntimeMetadata.json | ConvertFrom-Json).Sdk.Channel

$dotnetCLIRequiredVersion = $(Get-Content $PSScriptRoot/global.json | ConvertFrom-Json).Sdk.Version

# Track if tags have been sync'ed

$tagsUpToDate = $false

# Sync Tags

# When not using a branch in PowerShell/PowerShell, tags will not be fetched automatically

# Since code that uses Get-PSCommitID and Get-PSLatestTag assume that tags are fetched,

# This function can ensure that tags have been fetched.

# This function is used during the setup phase in tools/ci.psm1

function Sync-PSTags

{

param(

[Switch]

$AddRemoteIfMissing

)

$PowerShellRemoteUrl = "https://github.com/PowerShell/PowerShell.git"

$upstreamRemoteDefaultName = 'upstream'

$remotes = Start-NativeExecution {git --git-dir="$PSScriptRoot/.git" remote}

$upstreamRemote = $null

foreach($remote in $remotes)

{

$url = Start-NativeExecution {git --git-dir="$PSScriptRoot/.git" remote get-url $remote}

if($url -eq $PowerShellRemoteUrl)

{

$upstreamRemote = $remote

break

}

}

if(!$upstreamRemote -and $AddRemoteIfMissing.IsPresent -and $remotes -notcontains $upstreamRemoteDefaultName)

{

$null = Start-NativeExecution {git --git-dir="$PSScriptRoot/.git" remote add $upstreamRemoteDefaultName $PowerShellRemoteUrl}

$upstreamRemote = $upstreamRemoteDefaultName

}

elseif(!$upstreamRemote)

{

Write-Error "Please add a remote to PowerShell\PowerShell. Example: git remote add $upstreamRemoteDefaultName $PowerShellRemoteUrl" -ErrorAction Stop

}

$null = Start-NativeExecution {git --git-dir="$PSScriptRoot/.git" fetch --tags --quiet $upstreamRemote}

$script:tagsUpToDate=$true

}

# Gets the latest tag for the current branch

function Get-PSLatestTag

{

[CmdletBinding()]

param()

# This function won't always return the correct value unless tags have been sync'ed

# So, Write a warning to run Sync-PSTags

if(!$tagsUpToDate)

{

Write-Warning "Run Sync-PSTags to update tags"

}

return (Start-NativeExecution {git --git-dir="$PSScriptRoot/.git" describe --abbrev=0})

}

function Get-PSVersion

{

[CmdletBinding()]

param(

[switch]

$OmitCommitId

)

if($OmitCommitId.IsPresent)

{

return (Get-PSLatestTag) -replace '^v'

}

else

{

return (Get-PSCommitId) -replace '^v'

}

}

function Get-PSCommitId

{

[CmdletBinding()]

param()

# This function won't always return the correct value unless tags have been sync'ed

# So, Write a warning to run Sync-PSTags

if(!$tagsUpToDate)

{

Write-Warning "Run Sync-PSTags to update tags"

}

return (Start-NativeExecution {git --git-dir="$PSScriptRoot/.git" describe --dirty --abbrev=60})

}

function Get-EnvironmentInformation

{

$environment = @{'IsWindows' = [System.Environment]::OSVersion.Platform -eq [System.PlatformID]::Win32NT}

# PowerShell will likely not be built on pre-1709 nanoserver

if ('System.Management.Automation.Platform' -as [type]) {

$environment += @{'IsCoreCLR' = [System.Management.Automation.Platform]::IsCoreCLR}

$environment += @{'IsLinux' = [System.Management.Automation.Platform]::IsLinux}

$environment += @{'IsMacOS' = [System.Management.Automation.Platform]::IsMacOS}

} else {

$environment += @{'IsCoreCLR' = $false}

$environment += @{'IsLinux' = $false}

$environment += @{'IsMacOS' = $false}

}

if ($environment.IsWindows)

{

$environment += @{'IsAdmin' = (New-Object Security.Principal.WindowsPrincipal ([Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)}

$environment += @{'nugetPackagesRoot' = "${env:USERPROFILE}\.nuget\packages"}

}

else

{

$environment += @{'nugetPackagesRoot' = "${env:HOME}/.nuget/packages"}

}

if ($environment.IsMacOS) {

$environment += @{'UsingHomebrew' = [bool](Get-Command brew -ErrorAction ignore)}

$environment += @{'UsingMacports' = [bool](Get-Command port -ErrorAction ignore)}

if (-not($environment.UsingHomebrew -or $environment.UsingMacports)) {

throw "Neither Homebrew nor MacPorts is installed on this system, visit https://brew.sh/ or https://www.macports.org/ to continue"

}

}

if ($environment.IsLinux) {

$LinuxInfo = Get-Content /etc/os-release -Raw | ConvertFrom-StringData

$lsb_release = Get-Command lsb_release -Type Application -ErrorAction Ignore | Select-Object -First 1

if ($lsb_release) {

$LinuxID = & $lsb_release -is

}

else {

$LinuxID = ""

}

$environment += @{'LinuxInfo' = $LinuxInfo}

$environment += @{'IsDebian' = $LinuxInfo.ID -match 'debian' -or $LinuxInfo.ID -match 'kali'}

$environment += @{'IsDebian9' = $environment.IsDebian -and $LinuxInfo.VERSION_ID -match '9'}

$environment += @{'IsDebian10' = $environment.IsDebian -and $LinuxInfo.VERSION_ID -match '10'}

$environment += @{'IsDebian11' = $environment.IsDebian -and $LinuxInfo.PRETTY_NAME -match 'bullseye'}

$environment += @{'IsUbuntu' = $LinuxInfo.ID -match 'ubuntu' -or $LinuxID -match 'Ubuntu'}

$environment += @{'IsUbuntu16' = $environment.IsUbuntu -and $LinuxInfo.VERSION_ID -match '16.04'}

$environment += @{'IsUbuntu18' = $environment.IsUbuntu -and $LinuxInfo.VERSION_ID -match '18.04'}

$environment += @{'IsCentOS' = $LinuxInfo.ID -match 'centos' -and $LinuxInfo.VERSION_ID -match '7'}

$environment += @{'IsFedora' = $LinuxInfo.ID -match 'fedora' -and $LinuxInfo.VERSION_ID -ge 24}

$environment += @{'IsOpenSUSE' = $LinuxInfo.ID -match 'opensuse'}

$environment += @{'IsSLES' = $LinuxInfo.ID -match 'sles'}

$environment += @{'IsRedHat' = $LinuxInfo.ID -match 'rhel'}

$environment += @{'IsRedHat7' = $environment.IsRedHat -and $LinuxInfo.VERSION_ID -match '7' }

$environment += @{'IsOpenSUSE13' = $environment.IsOpenSUSE -and $LinuxInfo.VERSION_ID -match '13'}

$environment += @{'IsOpenSUSE42.1' = $environment.IsOpenSUSE -and $LinuxInfo.VERSION_ID -match '42.1'}

$environment += @{'IsDebianFamily' = $environment.IsDebian -or $environment.IsUbuntu}

$environment += @{'IsRedHatFamily' = $environment.IsCentOS -or $environment.IsFedora -or $environment.IsRedHat}

$environment += @{'IsSUSEFamily' = $environment.IsSLES -or $environment.IsOpenSUSE}

$environment += @{'IsAlpine' = $LinuxInfo.ID -match 'alpine'}

# Workaround for temporary LD_LIBRARY_PATH hack for Fedora 24

# https://github.com/PowerShell/PowerShell/issues/2511

if ($environment.IsFedora -and (Test-Path ENV:\LD_LIBRARY_PATH)) {

Remove-Item -Force ENV:\LD_LIBRARY_PATH

Get-ChildItem ENV:

}

if( -not(

$environment.IsDebian -or

$environment.IsUbuntu -or

$environment.IsRedHatFamily -or

$environment.IsSUSEFamily -or

$environment.IsAlpine)

) {

if ($SkipLinuxDistroCheck) {

Write-Warning "The current OS : $($LinuxInfo.ID) is not supported for building PowerShell."

} else {

throw "The current OS : $($LinuxInfo.ID) is not supported for building PowerShell. Import this module with '-ArgumentList `$true' to bypass this check."

}

}

}

return [PSCustomObject] $environment

}

$environment = Get-EnvironmentInformation

# Autoload (in current session) temporary modules used in our tests

$TestModulePath = Join-Path $PSScriptRoot "test/tools/Modules"

if ( -not $env:PSModulePath.Contains($TestModulePath) ) {

$env:PSModulePath = $TestModulePath+$TestModulePathSeparator+$($env:PSModulePath)

}

<#

.Synopsis

Tests if a version is preview

.EXAMPLE

Test-IsPreview -version '6.1.0-sometthing' # returns true

Test-IsPreview -version '6.1.0' # returns false

#>

function Test-IsPreview

{

param(

[parameter(Mandatory)]

[string]

$Version,

[switch]$IsLTS

)

if ($IsLTS.IsPresent) {

## If we are building a LTS package, then never consider it preview.

return $false

}

return $Version -like '*-*'

}

<#

.Synopsis

Tests if a version is a Release Candidate

.EXAMPLE

Test-IsReleaseCandidate -version '6.1.0-sometthing' # returns false

Test-IsReleaseCandidate -version '6.1.0-rc.1' # returns true

Test-IsReleaseCandidate -version '6.1.0' # returns false

#>

function Test-IsReleaseCandidate

{

param(

[parameter(Mandatory)]

[string]

$Version

)

if ($Version -like '*-rc.*')

{

return $true

}

return $false

}

function Start-PSBuild {

[CmdletBinding(DefaultParameterSetName="Default")]

param(

# When specified this switch will stops running dev powershell

# to help avoid compilation error, because file are in use.

[switch]$StopDevPowerShell,

[switch]$Restore,

# Accept a path to the output directory

# When specified, --output <path> will be passed to dotnet

[string]$Output,

[switch]$ResGen,

[switch]$TypeGen,

[switch]$Clean,

[Parameter(ParameterSetName="Legacy")]

[switch]$PSModuleRestore,

[Parameter(ParameterSetName="Default")]

[switch]$NoPSModuleRestore,

[switch]$CI,

# Skips the step where the pwsh that's been built is used to create a configuration

# Useful when changing parsing/compilation, since bugs there can mean we can't get past this step

[switch]$SkipExperimentalFeatureGeneration,

# this switch will re-build only System.Management.Automation.dll

# it's useful for development, to do a quick changes in the engine

[switch]$SMAOnly,

# These runtimes must match those in project.json

# We do not use ValidateScript since we want tab completion

# If this parameter is not provided it will get determined automatically.

[ValidateSet("alpine-x64",

"fxdependent",

"fxdependent-win-desktop",

"linux-arm",

"linux-arm64",

"linux-x64",

"osx-x64",

"win-arm",

"win-arm64",

"win7-x64",

"win7-x86")]

[string]$Runtime,

[ValidateSet('Debug', 'Release', 'CodeCoverage', '')] # We might need "Checked" as well

[string]$Configuration,

[switch]$CrossGen,

[ValidatePattern("^v\d+\.\d+\.\d+(-\w+(\.\d+)?)?$")]

[ValidateNotNullOrEmpty()]

[string]$ReleaseTag,

[switch]$Detailed

)

if ($PSCmdlet.ParameterSetName -eq "Default" -and !$NoPSModuleRestore)

{

$PSModuleRestore = $true

}

if ($Runtime -eq "linux-arm" -and $environment.IsLinux -and -not $environment.IsUbuntu) {

throw "Cross compiling for linux-arm is only supported on Ubuntu environment"

}

if ("win-arm","win-arm64" -contains $Runtime -and -not $environment.IsWindows) {

throw "Cross compiling for win-arm or win-arm64 is only supported on Windows environment"

}

function Stop-DevPowerShell {

Get-Process pwsh* |

Where-Object {

$_.Modules |

Where-Object {

$_.FileName -eq (Resolve-Path $script:Options.Output).Path

}

} |

Stop-Process -Verbose

}

if ($Clean) {

Write-Log "Cleaning your working directory. You can also do it with 'git clean -fdX --exclude .vs/PowerShell/v16/Server/sqlite3'"

Push-Location $PSScriptRoot

try {

# Excluded sqlite3 folder is due to this Roslyn issue: https://github.com/dotnet/roslyn/issues/23060

# Excluded src/Modules/nuget.config as this is required for release build.

git clean -fdX --exclude .vs/PowerShell/v16/Server/sqlite3 --exclude src/Modules/nuget.config

} finally {

Pop-Location

}

}

# Add .NET CLI tools to PATH

Find-Dotnet

# Verify we have .NET SDK in place to do the build, and abort if the precheck failed

$precheck = precheck 'dotnet' "Build dependency 'dotnet' not found in PATH. Run Start-PSBootstrap. Also see: https://dotnet.github.io/getting-started/"

if (-not $precheck) {

return

}

# Verify if the dotnet in-use is the required version

$dotnetCLIInstalledVersion = Start-NativeExecution -sb { dotnet --version } -IgnoreExitcode

If ($dotnetCLIInstalledVersion -ne $dotnetCLIRequiredVersion) {

Write-Warning @"

The currently installed .NET Command Line Tools is not the required version.

Installed version: $dotnetCLIInstalledVersion

Required version: $dotnetCLIRequiredVersion

Fix steps:

1. Remove the installed version from:

- on windows '`$env:LOCALAPPDATA\Microsoft\dotnet'

- on macOS and linux '`$env:HOME/.dotnet'

2. Run Start-PSBootstrap or Install-Dotnet

3. Start-PSBuild -Clean

`n

"@

return

}

# set output options

$OptionsArguments = @{

CrossGen=$CrossGen

Output=$Output

Runtime=$Runtime

Configuration=$Configuration

Verbose=$true

SMAOnly=[bool]$SMAOnly

PSModuleRestore=$PSModuleRestore

}

$script:Options = New-PSOptions @OptionsArguments

if ($StopDevPowerShell) {

Stop-DevPowerShell

}

# setup arguments

$Arguments = @("publish","--no-restore","/property:GenerateFullPaths=true")

if ($Output -or $SMAOnly) {

$Arguments += "--output", (Split-Path $Options.Output)

}

if ($Options.Runtime -like 'win*' -or ($Options.Runtime -like 'fxdependent*' -and $environment.IsWindows)) {

$Arguments += "/property:IsWindows=true"

}

else {

$Arguments += "/property:IsWindows=false"

}

# Framework Dependent builds do not support ReadyToRun as it needs a specific runtime to optimize for.

# The property is set in Powershell.Common.props file.

# We override the property through the build command line.

if($Options.Runtime -like 'fxdependent*') {

$Arguments += "/property:PublishReadyToRun=false"

}

$Arguments += "--configuration", $Options.Configuration

$Arguments += "--framework", $Options.Framework

if ($Detailed.IsPresent)

{

$Arguments += '--verbosity', 'd'

}

if (-not $SMAOnly -and $Options.Runtime -notlike 'fxdependent*') {

# libraries should not have runtime

$Arguments += "--runtime", $Options.Runtime

}

if ($ReleaseTag) {

$ReleaseTagToUse = $ReleaseTag -Replace '^v'

$Arguments += "/property:ReleaseTag=$ReleaseTagToUse"

}

# handle Restore

Restore-PSPackage -Options $Options -Force:$Restore

# handle ResGen

# Heuristic to run ResGen on the fresh machine

if ($ResGen -or -not (Test-Path "$PSScriptRoot/src/Microsoft.PowerShell.ConsoleHost/gen")) {

Write-Log "Run ResGen (generating C# bindings for resx files)"

Start-ResGen

}

# Handle TypeGen

# .inc file name must be different for Windows and Linux to allow build on Windows and WSL.

$incFileName = "powershell_$($Options.Runtime).inc"

if ($TypeGen -or -not (Test-Path "$PSScriptRoot/src/TypeCatalogGen/$incFileName")) {

Write-Log "Run TypeGen (generating CorePsTypeCatalog.cs)"

Start-TypeGen -IncFileName $incFileName

}

# Get the folder path where pwsh.exe is located.

if ((Split-Path $Options.Output -Leaf) -like "pwsh*") {

$publishPath = Split-Path $Options.Output -Parent

}

else {

$publishPath = $Options.Output

}

try {

# Relative paths do not work well if cwd is not changed to project

Push-Location $Options.Top

if ($Options.Runtime -notlike 'fxdependent*') {

if ($Options.Runtime -like 'win-arm*') {

$Arguments += "/property:SDKToUse=Microsoft.NET.Sdk"

} else {

$Arguments += "/property:SDKToUse=Microsoft.NET.Sdk.WindowsDesktop"

}

Write-Log "Run dotnet $Arguments from $PWD"

Start-NativeExecution { dotnet $Arguments }

Write-Log "PowerShell output: $($Options.Output)"

if ($CrossGen) {

## fxdependent package cannot be CrossGen'ed

Start-CrossGen -PublishPath $publishPath -Runtime $script:Options.Runtime

Write-Log "pwsh.exe with ngen binaries is available at: $($Options.Output)"

}

} else {

$globalToolSrcFolder = Resolve-Path (Join-Path $Options.Top "../Microsoft.PowerShell.GlobalTool.Shim") | Select-Object -ExpandProperty Path

if ($Options.Runtime -eq 'fxdependent') {

$Arguments += "/property:SDKToUse=Microsoft.NET.Sdk"

} elseif ($Options.Runtime -eq 'fxdependent-win-desktop') {

$Arguments += "/property:SDKToUse=Microsoft.NET.Sdk.WindowsDesktop"

}

Write-Log "Run dotnet $Arguments from $PWD"

Start-NativeExecution { dotnet $Arguments }

Write-Log "PowerShell output: $($Options.Output)"

try {

Push-Location $globalToolSrcFolder

$Arguments += "--output", $publishPath

Write-Log "Run dotnet $Arguments from $PWD to build global tool entry point"

Start-NativeExecution { dotnet $Arguments }

}

finally {

Pop-Location

}

}

} finally {

Pop-Location

}

# No extra post-building task will run if '-SMAOnly' is specified, because its purpose is for a quick update of S.M.A.dll after full build.

if ($SMAOnly) {

return

}

# publish reference assemblies

try {

Push-Location "$PSScriptRoot/src/TypeCatalogGen"

$refAssemblies = Get-Content -Path $incFileName | Where-Object { $_ -like "*microsoft.netcore.app*" } | ForEach-Object { $_.TrimEnd(';') }

$refDestFolder = Join-Path -Path $publishPath -ChildPath "ref"

if (Test-Path $refDestFolder -PathType Container) {

Remove-Item $refDestFolder -Force -Recurse -ErrorAction Stop

}

New-Item -Path $refDestFolder -ItemType Directory -Force -ErrorAction Stop > $null

Copy-Item -Path $refAssemblies -Destination $refDestFolder -Force -ErrorAction Stop

} finally {

Pop-Location

}

if ($ReleaseTag) {

$psVersion = $ReleaseTag

}

else {

$psVersion = git --git-dir="$PSScriptRoot/.git" describe

}

if ($environment.IsLinux) {

if ($environment.IsRedHatFamily -or $environment.IsDebian) {

# Symbolic links added here do NOT affect packaging as we do not build on Debian.

# add two symbolic links to system shared libraries that libmi.so is dependent on to handle

# platform specific changes. This is the only set of platforms needed for this currently

# as Ubuntu has these specific library files in the platform and macOS builds for itself

# against the correct versions.

if ($environment.IsDebian10 -or $environment.IsDebian11){

$sslTarget = "/usr/lib/x86_64-linux-gnu/libssl.so.1.1"

$cryptoTarget = "/usr/lib/x86_64-linux-gnu/libcrypto.so.1.1"

}

elseif ($environment.IsDebian9){

# NOTE: Debian 8 doesn't need these symlinks

$sslTarget = "/usr/lib/x86_64-linux-gnu/libssl.so.1.0.2"

$cryptoTarget = "/usr/lib/x86_64-linux-gnu/libcrypto.so.1.0.2"

}

else { #IsRedHatFamily

$sslTarget = "/lib64/libssl.so.10"

$cryptoTarget = "/lib64/libcrypto.so.10"

}

if ( ! (Test-Path "$publishPath/libssl.so.1.0.0")) {

$null = New-Item -Force -ItemType SymbolicLink -Target $sslTarget -Path "$publishPath/libssl.so.1.0.0" -ErrorAction Stop

}

if ( ! (Test-Path "$publishPath/libcrypto.so.1.0.0")) {

$null = New-Item -Force -ItemType SymbolicLink -Target $cryptoTarget -Path "$publishPath/libcrypto.so.1.0.0" -ErrorAction Stop

}

}

}

# download modules from powershell gallery.

# - PowerShellGet, PackageManagement, Microsoft.PowerShell.Archive

if ($PSModuleRestore) {

Restore-PSModuleToBuild -PublishPath $publishPath

}

# publish powershell.config.json

$config = @{}

if ($environment.IsWindows) {

$config = @{ "Microsoft.PowerShell:ExecutionPolicy" = "RemoteSigned";

"WindowsPowerShellCompatibilityModuleDenyList" = @("PSScheduledJob","BestPractices","UpdateServices") }

}

# When building preview, we want the configuration to enable all experiemental features by default

# ARM is cross compiled, so we can't run pwsh to enumerate Experimental Features

if (-not $SkipExperimentalFeatureGeneration -and

(Test-IsPreview $psVersion) -and

-not (Test-IsReleaseCandidate $psVersion) -and

-not $Runtime.Contains("arm") -and

-not ($Runtime -like 'fxdependent*')) {

$json = & $publishPath\pwsh -noprofile -command {

$expFeatures = [System.Collections.Generic.List[string]]::new()

Get-ExperimentalFeature | ForEach-Object { $expFeatures.Add($_.Name) }

# Make sure ExperimentalFeatures from modules in PSHome are added

# https://github.com/PowerShell/PowerShell/issues/10550

@("PSDesiredStateConfiguration.InvokeDscResource") | ForEach-Object {

if (!$expFeatures.Contains($_)) {

$expFeatures.Add($_)

}

}

ConvertTo-Json $expFeatures.ToArray()

}

$config += @{ ExperimentalFeatures = ([string[]] ($json | ConvertFrom-Json)) }

}

if ($config.Count -gt 0) {

$configPublishPath = Join-Path -Path $publishPath -ChildPath "powershell.config.json"

Set-Content -Path $configPublishPath -Value ($config | ConvertTo-Json) -Force -ErrorAction Stop

}

# Restore the Pester module

if ($CI) {

Restore-PSPester -Destination (Join-Path $publishPath "Modules")

}

}

function Restore-PSPackage

{

[CmdletBinding()]

param(

[ValidateNotNullOrEmpty()]

[Parameter()]

[string[]] $ProjectDirs,

[ValidateNotNullOrEmpty()]

[Parameter()]

$Options = (Get-PSOptions -DefaultToNew),

[switch] $Force

)

if (-not $ProjectDirs)

{

$ProjectDirs = @($Options.Top, "$PSScriptRoot/src/TypeCatalogGen", "$PSScriptRoot/src/ResGen", "$PSScriptRoot/src/Modules")

if ($Options.Runtime -like 'fxdependent*') {

$ProjectDirs += "$PSScriptRoot/src/Microsoft.PowerShell.GlobalTool.Shim"

}

}

if ($Force -or (-not (Test-Path "$($Options.Top)/obj/project.assets.json"))) {

$sdkToUse = if (($Options.Runtime -eq 'fxdependent-win-desktop' -or $Options.Runtime -like 'win*')) { # this is fxd or some windows runtime

if ($Options.Runtime -like 'win-arm*') {

'Microsoft.NET.Sdk'

} else {

'Microsoft.NET.Sdk.WindowsDesktop'

}

} else {

'Microsoft.NET.Sdk'

}

if ($Options.Runtime -notlike 'fxdependent*') {

$RestoreArguments = @("--runtime", $Options.Runtime, "/property:SDKToUse=$sdkToUse", "--verbosity")

} else {

$RestoreArguments = @("/property:SDKToUse=$sdkToUse", "--verbosity")

}

if ($VerbosePreference -eq 'Continue') {

$RestoreArguments += "detailed"

} else {

$RestoreArguments += "quiet"

}

$ProjectDirs | ForEach-Object {

$project = $_

Write-Log "Run dotnet restore $project $RestoreArguments"

$retryCount = 0

$maxTries = 5

while($retryCount -lt $maxTries)

{

try

{

Start-NativeExecution { dotnet restore $project $RestoreArguments }

}

catch

{

Write-Log "Failed to restore $project, retrying..."

$retryCount++

if($retryCount -ge $maxTries)

{

throw

}

continue

}

Write-Log "Done restoring $project"

break

}

}

}

}

function Restore-PSModuleToBuild

{

param(

[Parameter(Mandatory)]

[string]

$PublishPath

)

Write-Log "Restore PowerShell modules to $publishPath"

$modulesDir = Join-Path -Path $publishPath -ChildPath "Modules"

Copy-PSGalleryModules -Destination $modulesDir -CsProjPath "$PSScriptRoot\src\Modules\PSGalleryModules.csproj"

# Remove .nupkg.metadata files

Get-ChildItem $PublishPath -Filter '.nupkg.metadata' -Recurse | ForEach-Object { Remove-Item $_.FullName -ErrorAction SilentlyContinue -Force }

}

function Restore-PSPester

{

param(

[ValidateNotNullOrEmpty()]

[string] $Destination = ([IO.Path]::Combine((Split-Path (Get-PSOptions -DefaultToNew).Output), "Modules"))

)

Save-Module -Name Pester -Path $Destination -Repository PSGallery -MaximumVersion 4.99

}

function Compress-TestContent {

[CmdletBinding()]

param(

$Destination

)

$null = Publish-PSTestTools

$powerShellTestRoot = Join-Path $PSScriptRoot 'test'

Add-Type -AssemblyName System.IO.Compression.FileSystem

$resolvedPath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($Destination)

[System.IO.Compression.ZipFile]::CreateFromDirectory($powerShellTestRoot, $resolvedPath)

}

function New-PSOptions {

[CmdletBinding()]

param(

[ValidateSet("Debug", "Release", "CodeCoverage", '')]

[string]$Configuration,

[ValidateSet("net5.0")]

[string]$Framework = "net5.0",

# These are duplicated from Start-PSBuild

# We do not use ValidateScript since we want tab completion

[ValidateSet("",

"alpine-x64",

"fxdependent",

"fxdependent-win-desktop",

"linux-arm",

"linux-arm64",

"linux-x64",

"osx-x64",

"win-arm",

"win-arm64",

"win7-x64",

"win7-x86")]

[string]$Runtime,

[switch]$CrossGen,

# Accept a path to the output directory

# If not null or empty, name of the executable will be appended to

# this path, otherwise, to the default path, and then the full path

# of the output executable will be assigned to the Output property

[string]$Output,

[switch]$SMAOnly,

[switch]$PSModuleRestore

)

# Add .NET CLI tools to PATH

Find-Dotnet

if (-not $Configuration) {

$Configuration = 'Debug'

}

Write-Verbose "Using configuration '$Configuration'"

Write-Verbose "Using framework '$Framework'"

if (-not $Runtime) {

if ($environment.IsLinux) {

$Runtime = "linux-x64"

} elseif ($environment.IsMacOS) {

$Runtime = "osx-x64"

} else {

$RID = dotnet --info | ForEach-Object {

if ($_ -match "RID") {

$_ -split "\s+" | Select-Object -Last 1

}

}

# We plan to release packages targetting win7-x64 and win7-x86 RIDs,

# which supports all supported windows platforms.

# So we, will change the RID to win7-<arch>

$Runtime = $RID -replace "win\d+", "win7"

}

if (-not $Runtime) {

Throw "Could not determine Runtime Identifier, please update dotnet"

} else {

Write-Verbose "Using runtime '$Runtime'"

}

}

$PowerShellDir = if ($Runtime -like 'win*' -or ($Runtime -like 'fxdependent*' -and $environment.IsWindows)) {

"powershell-win-core"

} else {

"powershell-unix"

}

$Top = [IO.Path]::Combine($PSScriptRoot, "src", $PowerShellDir)

Write-Verbose "Top project directory is $Top"

$Executable = if ($Runtime -like 'fxdependent*') {

"pwsh.dll"

} elseif ($environment.IsLinux -or $environment.IsMacOS) {

"pwsh"

} elseif ($environment.IsWindows) {

"pwsh.exe"

}

# Build the Output path

if (!$Output) {

if ($Runtime -like 'fxdependent*') {

$Output = [IO.Path]::Combine($Top, "bin", $Configuration, $Framework, "publish", $Executable)

} else {

$Output = [IO.Path]::Combine($Top, "bin", $Configuration, $Framework, $Runtime, "publish", $Executable)

}

} else {

$Output = [IO.Path]::Combine($Output, $Executable)

}

if ($SMAOnly)

{

$Top = [IO.Path]::Combine($PSScriptRoot, "src", "System.Management.Automation")

}

$RootInfo = @{RepoPath = $PSScriptRoot}

# the valid root is the root of the filesystem and the folder PowerShell

$RootInfo['ValidPath'] = Join-Path -Path ([system.io.path]::GetPathRoot($RootInfo.RepoPath)) -ChildPath 'PowerShell'

if($RootInfo.RepoPath -ne $RootInfo.ValidPath)

{

$RootInfo['Warning'] = "Please ensure your repo is at the root of the file system and named 'PowerShell' (example: '$($RootInfo.ValidPath)'), when building and packaging for release!"

$RootInfo['IsValid'] = $false

}

else

{

$RootInfo['IsValid'] = $true

}

return New-PSOptionsObject `

-RootInfo ([PSCustomObject]$RootInfo) `

-Top $Top `

-Runtime $Runtime `

-Crossgen $Crossgen.IsPresent `

-Configuration $Configuration `

-PSModuleRestore $PSModuleRestore.IsPresent `

-Framework $Framework `

-Output $Output

}

# Get the Options of the last build

function Get-PSOptions {

param(

[Parameter(HelpMessage='Defaults to New-PSOption if a build has not occurred.')]

[switch]

$DefaultToNew

)

if (!$script:Options -and $DefaultToNew.IsPresent)

{

return New-PSOptions

}

return $script:Options

}

function Set-PSOptions {

param(

[PSObject]

$Options

)

$script:Options = $Options

}

function Get-PSOutput {

[CmdletBinding()]param(

[hashtable]$Options

)

if ($Options) {

return $Options.Output

} elseif ($script:Options) {

return $script:Options.Output

} else {

return (New-PSOptions).Output

}

}

function Get-PesterTag {

param ( [Parameter(Position=0)][string]$testbase = "$PSScriptRoot/test/powershell" )

$alltags = @{}

$warnings = @()

Get-ChildItem -Recurse $testbase -File | Where-Object {$_.name -match "tests.ps1"}| ForEach-Object {

$fullname = $_.fullname

$tok = $err = $null

$ast = [System.Management.Automation.Language.Parser]::ParseFile($FullName, [ref]$tok,[ref]$err)

$des = $ast.FindAll({

$args[0] -is [System.Management.Automation.Language.CommandAst] `

-and $args[0].CommandElements.GetType() -in @(

[System.Management.Automation.Language.StringConstantExpressionAst],

[System.Management.Automation.Language.ExpandableStringExpressionAst]

) `

-and $args[0].CommandElements[0].Value -eq "Describe"

}, $true)

foreach( $describe in $des) {

$elements = $describe.CommandElements

$lineno = $elements[0].Extent.StartLineNumber

$foundPriorityTags = @()

for ( $i = 0; $i -lt $elements.Count; $i++) {

if ( $elements[$i].extent.text -match "^-t" ) {

$vAst = $elements[$i+1]

if ( $vAst.FindAll({$args[0] -is "System.Management.Automation.Language.VariableExpressionAst"},$true) ) {

$warnings += "TAGS must be static strings, error in ${fullname}, line $lineno"

}

$values = $vAst.FindAll({$args[0] -is "System.Management.Automation.Language.StringConstantExpressionAst"},$true).Value

$values | ForEach-Object {

if (@('REQUIREADMINONWINDOWS', 'REQUIRESUDOONUNIX', 'SLOW') -contains $_) {

# These are valid tags also, but they are not the priority tags

}

elseif (@('CI', 'FEATURE', 'SCENARIO') -contains $_) {

$foundPriorityTags += $_

}

else {

$warnings += "${fullname} includes improper tag '$_', line '$lineno'"

}

$alltags[$_]++

}

}

}

if ( $foundPriorityTags.Count -eq 0 ) {

$warnings += "${fullname}:$lineno does not include -Tag in Describe"

}

elseif ( $foundPriorityTags.Count -gt 1 ) {

$warnings += "${fullname}:$lineno includes more then one scope -Tag: $foundPriorityTags"

}

}

}

if ( $Warnings.Count -gt 0 ) {

$alltags['Result'] = "Fail"

}

else {

$alltags['Result'] = "Pass"

}

$alltags['Warnings'] = $warnings

$o = [pscustomobject]$alltags

$o.psobject.TypeNames.Add("DescribeTagsInUse")

$o

}

function Publish-PSTestTools {

[CmdletBinding()]

param(

[string]

$runtime

)

Find-Dotnet

$tools = @(

@{Path="${PSScriptRoot}/test/tools/TestExe";Output="testexe"}

@{Path="${PSScriptRoot}/test/tools/WebListener";Output="WebListener"}

@{Path="${PSScriptRoot}/test/tools/TestService";Output="TestService"}

)

$Options = Get-PSOptions -DefaultToNew

# Publish tools so it can be run by tests

foreach ($tool in $tools)

{

Push-Location $tool.Path

try {

$toolPath = Join-Path -Path $tool.Path -ChildPath "bin"

$objPath = Join-Path -Path $tool.Path -ChildPath "obj"

if (Test-Path $toolPath) {

Remove-Item -Path $toolPath -Recurse -Force

}

if (Test-Path $objPath) {

Remove-Item -Path $objPath -Recurse -Force

}

if (-not $runtime) {

dotnet publish --output bin --configuration $Options.Configuration --framework $Options.Framework --runtime $Options.Runtime

} else {

dotnet publish --output bin --configuration $Options.Configuration --framework $Options.Framework --runtime $runtime

}

if ( -not $env:PATH.Contains($toolPath) ) {

$env:PATH = $toolPath+$TestModulePathSeparator+$($env:PATH)

}

} finally {