# Copyright (c) Microsoft Corporation.

# Licensed under the MIT License.

$script:forcePull = $true

# Get docker Engine OS

function Get-DockerEngineOs

{

docker info --format '{{ .OperatingSystem }}'

}

# Call Docker with appropriate result checksfunction Invoke-Docker

function Invoke-Docker

{

param(

[Parameter(Mandatory=$true)]

[string[]]

$Command,

[ValidateSet("error","warning",'ignore')]

$FailureAction = 'error',

[Parameter(Mandatory=$true)]

[string[]]

$Params,

[switch]

$PassThru,

[switch]

$SuppressHostOutput

)

$ErrorActionPreference = 'Continue'

# Log how we are running docker for troubleshooting issues

Write-Verbose "Running docker $command $params" -Verbose

if($SuppressHostOutput.IsPresent)

{

$result = docker $command $params 2>&1

}

else

{

&'docker' $command $params 2>&1 | Tee-Object -Variable result -ErrorAction SilentlyContinue | Out-String -Stream -ErrorAction SilentlyContinue | Write-Host -ErrorAction SilentlyContinue

}

$dockerExitCode = $LASTEXITCODE

if($PassThru.IsPresent)

{

Write-Verbose "passing through docker result$($result.length)..." -Verbose

return $result

}

elseif($dockerExitCode -ne 0 -and $FailureAction -eq 'error')

{

Write-Error "docker $command failed with: $result" -ErrorAction Stop

return $false

}

elseif($dockerExitCode -ne 0 -and $FailureAction -eq 'warning')

{

Write-Warning "docker $command failed with: $result"

return $false

}

elseif($dockerExitCode -ne 0)

{

return $false

}

return $true

}

# Return a list of Linux Container Test Cases

function Get-LinuxContainer

{

foreach($os in 'centos7','ubuntu16.04')

{

Write-Output @{

Name = $os

Path = "$PSScriptRoot/../release/$os"

}

}

}

# Return a list of Windows Container Test Cases

function Get-WindowsContainer

{

foreach($os in 'windowsservercore','nanoserver')

{

Write-Output @{

Name = $os

Path = "$PSScriptRoot/../release/$os"

}

}

}

$script:repoName = 'microsoft/powershell'

function Get-RepoName

{

return $script:repoName

}

function Set-RepoName

{

param([string]$RepoName)

$script:repoName = $RepoName

$script:forcePull = $false

}

function Test-SkipWindows

{

[bool] $canRunWindows = (Get-DockerEngineOs) -like 'Windows*'

return ($IsLinux -or $IsMacOS -or !$canRunWindows)

}

function Test-SkipLinux

{

$os = Get-DockerEngineOs

switch -wildcard ($os)

{

'*Linux*' {

return $false

}

'*Mac' {

return $false

}

# Docker for Windows means we are running the linux kernel

'Docker for Windows' {

return $false

}

'Windows*' {

return $true

}

default {

throw "Unknown docker os '$os'"

}

}

}

function Get-TestContext

{

param(

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

[string]$Type

)

$resultFileName = 'results.xml'

$logFileName = 'results.log'

$containerTestDrive = '/test'

# Return a windows context if the Context in Windows *AND*

# the current system is windows, otherwise Join-path will fail.

if($Type -eq 'Windows' -and $IsWindows)

{

$ContainerTestDrive = 'C:\test'

}

$resolvedTestDrive = (Resolve-Path "Testdrive:\").providerPath

return @{

ResolvedTestDrive = $resolvedTestDrive

ResolvedXmlPath = Join-Path $resolvedTestDrive -ChildPath $resultFileName

ResolvedLogPath = Join-Path $resolvedTestDrive -ChildPath $logFileName

ContainerTestDrive = $ContainerTestDrive

ContainerXmlPath = Join-Path $containerTestDrive -ChildPath $resultFileName

ContainerLogPath = Join-Path $containerTestDrive -ChildPath $logFileName

Type = $Type

ForcePull = $script:forcePull

}

}

function Get-ContainerPowerShellVersion

{

param(

[HashTable] $TestContext,

[string] $RepoName,

[string] $Name

)

$imageTag = "${script:repoName}:${Name}"

if($TestContext.ForcePull)

{

$null=Invoke-Docker -Command 'image', 'pull' -Params $imageTag -SuppressHostOutput

}

$runParams = @()

$localVolumeName = $testContext.resolvedTestDrive

$runParams += '--rm'

if($TestContext.Type -ne 'Windows' -and $IsWindows)

{

# use a container volume on windows because host volumes are not automatic

$volumeName = "test-volume-" + (Get-Random -Minimum 100 -Maximum 999)

# using alpine because it's tiny

$null=Invoke-Docker -Command create -Params '-v', '/test', '--name', $volumeName, 'alpine' -SuppressHostOutput

$runParams += '--volumes-from'

$runParams += $volumeName

}

else {

$runParams += '-v'

$runParams += "${localVolumeName}:$($testContext.containerTestDrive)"

}

$runParams += $imageTag

$runParams += 'pwsh'

$runParams += '-c'

$runParams += ('$PSVersionTable.PSVersion.ToString() | out-string | out-file -encoding ascii -FilePath '+$testContext.containerLogPath)

$null = Invoke-Docker -Command run -Params $runParams -SuppressHostOutput

if($TestContext.Type -ne 'Windows' -and $IsWindows)

{

$null = Invoke-Docker -Command cp -Params "${volumeName}:$($testContext.containerLogPath)", $TestContext.ResolvedLogPath

$null = Invoke-Docker -Command container, rm -Params $volumeName, '--force' -SuppressHostOutput

}

return (Get-Content -Encoding Ascii $testContext.resolvedLogPath)[0]

}

# Function defines a config mapping for testing Preview packages.

# The list of supported OS for each release can be found here:

# https://github.com/PowerShell/PowerShell-Docs/blob/staging/reference/docs-conceptual/PowerShell-Core-Support.md#supported-platforms

function Get-DefaultPreviewConfigForPackageValidation

{

# format: <DockerfileFolderName>=<PartOfPackageFilename>

@{ 'centos7'='rhel.7';

'debian.9'='debian.9';

'fedora28'='rhel.7';

'opensuse42.3'='linux-x64.tar.gz';

'ubuntu16.04'='ubuntu.16.04';

'ubuntu18.04'='ubuntu.18.04';

'fxdependent-centos7'='linux-x64-fxdependent.tar.gz';

'fxdependent-debian.9'='linux-x64-fxdependent.tar.gz';

'fxdependent-fedora28'='linux-x64-fxdependent.tar.gz';

'fxdependent-opensuse42.3'='linux-x64-fxdependent.tar.gz';

'fxdependent-ubuntu16.04'='linux-x64-fxdependent.tar.gz';

'fxdependent-ubuntu18.04'='linux-x64-fxdependent.tar.gz';

'fxdependent-dotnetsdk-latest'='linux-x64-fxd-dotnetsdk.tar.gz'

}

}

# Function defines a config mapping for testing Stable packages.

# The list of supported OS for each release can be found here:

# https://github.com/PowerShell/PowerShell-Docs/blob/staging/reference/docs-conceptual/PowerShell-Core-Support.md#supported-platforms

function Get-DefaultStableConfigForPackageValidation

{

# format: <DockerfileFolderName>=<PartOfPackageFilename>

@{ 'centos7'='rhel.7';

'debian.9'='debian.9';

'opensuse42.3'='linux-x64.tar.gz';

'ubuntu16.04'='ubuntu.16.04';

'fxdependent-centos7'='linux-x64-fxdependent.tar.gz';

'fxdependent-debian.9'='linux-x64-fxdependent.tar.gz';

'fxdependent-opensuse42.3'='linux-x64-fxdependent.tar.gz';

'fxdependent-ubuntu16.04'='linux-x64-fxdependent.tar.gz'

}

}

# Returns a list of files in a specified Azure container.

function Get-PackageNamesOnAzureBlob

{

param(

[string]

$ContainerUrl,

# $SAS (shared access signature) param should include beginning '?' and trailing '&'

[string]

$SAS

)

$response = Invoke-RestMethod -Method Get -Uri $($ContainerUrl + $SAS + 'restype=container&comp=list')

$xmlResponce = [xml]$response.Substring($response.IndexOf('<EnumerationResults')) # remove some bad chars in the beginning that break XML parsing

($xmlResponce.EnumerationResults.Blobs.Blob).Name

}

# This function is used for basic validation of PS packages during a release;

# During the process Docker files are filled out and executed with Docker build;

# During the build PS packages are downloaded onto Docker containers, installed and selected Pester tests from PowerShell Github repo are executed.

# This function must be run on a Docker host machine in 'Linux containers' mode, such as Windows 10 server with Hyper-V role installed.

function Test-PSPackage

{

param(

[string]

[Parameter(Mandatory=$true)]

$PSPackageLocation, # e.g. Azure container storage url

[string]

$SAS,# $SAS (shared access signature) param should include beginning '?' and trailing '&'

[Hashtable]

$Config, # hashtable that maps packages to dockerfiles; for example see Get-DefaultConfigForPackageValidation

[string]

$TestList = "/PowerShell/test/powershell/Modules/PackageManagement/PackageManagement.Tests.ps1,/PowerShell/test/powershell/engine/Module",

[string]

$TestDownloadCommand = "git clone --recursive https://github.com/PowerShell/PowerShell.git",

[switch]

$Preview = $false

)

$PSPackageLocation = $PSPackageLocation.TrimEnd('/','\') # code below assumes there is no trailing separator in PSPackageLocation url

$RootFolder = Join-Path $PSScriptRoot 'Templates'

$packageList = Get-PackageNamesOnAzureBlob -ContainerUrl $PSPackageLocation -SAS $SAS

if (!$Config)

{

if ($Preview)

{

$Config = Get-DefaultPreviewConfigForPackageValidation

}

else

{

$Config = Get-DefaultStableConfigForPackageValidation

}

}

# pre-process $Config: verify build directories and packages exist

$map = @{}

foreach($kp in $Config.GetEnumerator())

{

$buildDir = Join-Path $RootFolder $kp.Key

$packageName = $packageList | Where-Object {$_ -like $('*'+$kp.Value+'*')}

if (-not (Test-Path $buildDir))

{

Write-Error "Directory does Not exist - $buildDir; Check `$Config parameter and '$RootFolder' folder"

}

elseif (-not ($packageName))

{

Write-Error "Can not find package that matches filter *$($kp.Value)*; Check `$Config parameter and '$PSPackageLocation'"

}

else

{

$map.Add($buildDir, $packageName)

}

}

Write-Verbose "Using configuration:" -Verbose

Write-Verbose ($map | Format-List | Out-String) -Verbose

$results = @{}

$returnValue = $true

# run builds sequentially, but don't block for errors so that configs after failed one can run

foreach($kp in $map.GetEnumerator())

{

$dockerDirPath = $kp.Key

$packageFileName = $kp.Value

$buildArgs = @()

$buildArgs += "--build-arg","PACKAGENAME=$packageFileName"

$buildArgs += "--build-arg","PACKAGELOCATION=$PSPackageLocation"

if ($Preview)

{

$buildArgs += "--build-arg","PREVIEWSUFFIX=-preview"

}

$buildArgs += "--build-arg","TESTLIST=$TestList"

$buildArgs += "--build-arg","TESTDOWNLOADCOMMAND=$TestDownloadCommand"

$buildArgs += "--no-cache"

$buildArgs += $dockerDirPath

$dockerResult = Invoke-Docker -Command 'build' -Params $buildArgs -FailureAction warning

$confName = Split-Path -Leaf $dockerDirPath

$results.Add($confName, $dockerResult)

if (-not $dockerResult) {$returnValue = $false}

}

# in the end print results for all configurations

Write-Verbose "Package validation results:" -Verbose

$results

return $returnValue

}