maxmustermann/PowerShell
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Add ability to package all of powershell core as a NuGet Package (#4363)

Browse source 
So that PowerShell can be installed using PackageManagement cmdlets find-package and install-package.
This commit is contained in:
Travis Plunk 2017-08-01 14:35:50 -07:00 committed by Dongbo Wang
parent 10a27b891a
commit e829053e9e
9 changed files with 445 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -38,6 +38,7 @@ dotnet-uninstall-debian-packages.sh
*.zip
*.rpm
*.pkg
*.nupkg
# ignore the version file as it is generated at build time
powershell.version

2
appveyor.yml
View file

@ -1,4 +1,4 @@
version: 6.0.0-beta.4-{build}
# version is set in tools\appveyor.psm1 - Invoke-AppVeyorInstall
image: Visual Studio 2017

125
build.psm1
View file

@ -5,6 +5,90 @@ $script:TestModulePathSeparator = [System.IO.Path]::PathSeparator
$dotnetCLIChannel = "preview"
$dotnetCLIRequiredVersion = "2.0.0-preview2-006502"
# 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/appveyor.psm1 and tools/travis.ps1
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
{
# 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
{
param(
[switch]
$OmitCommitId
)
if($OmitCommitId.IsPresent)
{
return (Get-PSLatestTag) -replace '^v'
}
else
{
return (Get-PSCommitId) -replace '^v'
}
}
function Get-PSCommitId
{
# 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 = @{}
@ -268,7 +352,7 @@ function Start-PSBuild {
$gitCommitId = $ReleaseTag
if (-not $gitCommitId) {
# if ReleaseTag is not specified, use 'git describe' to get the commit id
$gitCommitId = git --git-dir="$PSScriptRoot/.git" describe --dirty --abbrev=60
$gitCommitId = Get-PSCommitId
}
$gitCommitId > "$psscriptroot/powershell.version"
@ -1934,35 +2018,6 @@ function script:Start-NativeExecution([scriptblock]$sb, [switch]$IgnoreExitcode)
}
}
# Builds coming out of this project can have version number as 'a.b.c-stringf.d-e-f' OR 'a.b.c.d-e-f'
# This function converts the above version into semantic version major.minor[.build-quality[.revision]] format
function Get-PackageSemanticVersion
{
[CmdletBinding()]
param (
# Version of the Package
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $Version
)
Write-Verbose "Extract the semantic version in the form of major.minor[.build-quality[.revision]] for $Version"
$packageVersionTokens = $Version.Split('.')
if (3 -eq $packageVersionTokens.Count) {
# In case the input is of the form a.b.c, add a '0' at the end for revision field
$packageSemanticVersion = $Version,'0' -join '.'
} elseif (3 -lt $packageVersionTokens.Count) {
# We have all the four fields
$packageRevisionTokens = ($packageVersionTokens[3].Split('-'))[0]
$packageSemanticVersion = $packageVersionTokens[0],$packageVersionTokens[1],$packageVersionTokens[2],$packageRevisionTokens -join '.'
} else {
throw "Cannot create Semantic Version from the string $Version containing 4 or more tokens"
}
$packageSemanticVersion
}
# Builds coming out of this project can have version number as 'a.b.c' OR 'a.b.c-d-f'
# This function converts the above version into major.minor[.build[.revision]] format
function Get-PackageVersionAsMajorMinorBuildRevision
@ -2035,8 +2090,10 @@ function New-MSIPackage
[Parameter(Mandatory = $true)]
[ValidateSet("x86", "x64")]
[ValidateNotNullOrEmpty()]
[string] $ProductTargetArchitecture
[string] $ProductTargetArchitecture,
# Force overwrite of package
[Switch] $Force
)
## AppVeyor base image might update the version for Wix. Hence, we should
@ -2095,7 +2152,11 @@ function New-MSIPackage
$packageName += "-$ProductNameSuffix"
}
$msiLocationPath = Join-Path $pwd "$packageName.msi"
Remove-Item -ErrorAction SilentlyContinue $msiLocationPath -Force
if(!$Force.IsPresent -and (Test-Path -Path $msiLocationPath))
{
Write-Error -Message "Package already exists, use -Force to overwrite, path: $msiLocationPath" -ErrorAction Stop
}
& $wixHeatExePath dir $ProductSourcePath -dr $productVersionWithName -cg $productVersionWithName -gg -sfrag -srd -scom -sreg -out $wixFragmentPath -var env.ProductSourcePath -v | Write-Verbose
& $wixCandleExePath "$ProductWxsPath" "$wixFragmentPath" -out (Join-Path "$env:Temp" "\\") -ext WixUIExtension -ext WixUtilExtension -arch x64 -v | Write-Verbose

21
tools/appveyor.psm1
View file

@ -189,6 +189,13 @@ function Invoke-AppVeyorBuild
# Implements the AppVeyor 'install' step
function Invoke-AppVeyorInstall
{
# Make sure we have all the tags
Sync-PSTags -AddRemoteIfMissing
if($env:APPVEYOR_BUILD_NUMBER)
{
Update-AppveyorBuild -Version "$(Get-PSVersion -OmitCommitId)-$env:APPVEYOR_BUILD_NUMBER"
}
if(Test-DailyBuild){
$buildName = "[Daily]"
@ -434,8 +441,14 @@ function Get-PackageName
function Invoke-AppveyorFinish
{
try {
$packageParams = @{}
if($env:APPVEYOR_BUILD_VERSION)
{
$packageParams += @{Version=$env:APPVEYOR_BUILD_VERSION}
}
# Build packages
$packages = Start-PSPackage
$packages = Start-PSPackage @packageParams
$name = Get-PackageName
@ -503,6 +516,12 @@ function Invoke-AppveyorFinish
$pushedAllArtifacts = $false
Write-Warning "Artifact $_ does not exist."
}
if($env:NUGET_KEY -and $env:NUGET_URL -and [system.io.path]::GetExtension($_) -ieq '.nupkg')
{
log "pushing $_ to $env:NUGET_URL"
Start-NativeExecution -sb {dotnet nuget push $_ --api-key $env:NUGET_KEY --source "$env:NUGET_URL/api/v2/package"} -IgnoreExitcode
}
}
if(!$pushedAllArtifacts)
{

2
tools/packaging/.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
staging/
nugetStaging/

303
tools/packaging/packaging.psm1
View file

@ -19,13 +19,15 @@ function Start-PSPackage {
[string]$Name = "powershell",
# Ubuntu, CentOS, Fedora, OS X, and Windows packages are supported
[ValidateSet("deb", "osxpkg", "rpm", "msi", "appx", "zip", "AppImage")]
[ValidateSet("deb", "osxpkg", "rpm", "msi", "appx", "zip", "AppImage", "nupkg")]
[string[]]$Type,
# Generate windows downlevel package
[ValidateSet("win81-x64", "win7-x86", "win7-x64")]
[ValidateScript({$Environment.IsWindows})]
[string]$WindowsDownLevel
[string]$WindowsDownLevel,
[Switch] $Force
)
# Runtime and Configuration settings required by the package
@ -34,10 +36,10 @@ function Start-PSPackage {
} else {
New-PSOptions -Configuration "Release" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }
}
Write-Verbose "Packaging RID: '$Runtime'; Packaging Configuration: '$Configuration'" -Verbose
log "Packaging RID: '$Runtime'; Packaging Configuration: '$Configuration'"
$Script:Options = Get-PSOptions
# Make sure the most recent build satisfies the package requirement
if (-not $Script:Options -or ## Start-PSBuild hasn't been executed yet
-not $Script:Options.CrossGen -or ## Last build didn't specify -CrossGen
@ -72,26 +74,26 @@ function Start-PSPackage {
}
$Source = Split-Path -Path $Script:Options.Output -Parent
Write-Verbose "Packaging Source: '$Source'" -Verbose
log "Packaging Source: '$Source'"
# Decide package output type
if (-not $Type) {
$Type = if ($Environment.IsLinux) {
if ($Environment.LinuxInfo.ID -match "ubuntu") {
"deb"
"deb", "nupkg"
} elseif ($Environment.IsRedHatFamily) {
"rpm"
"rpm", "nupkg"
} else {
throw "Building packages for $($Environment.LinuxInfo.PRETTY_NAME) is unsupported!"
}
} elseif ($Environment.IsOSX) {
"osxpkg"
"osxpkg", "nupkg"
} elseif ($Environment.IsWindows) {
"msi", "appx"
"msi", "nupkg"
}
Write-Warning "-Type was not specified, continuing with $Type!"
}
Write-Verbose "Packaging Type: $Type" -Verbose
log "Packaging Type: $Type"
# Build the name suffix for win-plat packages
if ($Environment.IsWindows) {
@ -110,6 +112,7 @@ function Start-PSPackage {
PackageNameSuffix = $NameSuffix
PackageSourcePath = $Source
PackageVersion = $Version
Force = $Force
}
if($pscmdlet.ShouldProcess("Create Zip Package"))
@ -132,7 +135,8 @@ function Start-PSPackage {
LicenseFilePath = "$PSScriptRoot\..\..\assets\license.rtf"
# Product Guid needs to be unique for every PowerShell version to allow SxS install
ProductGuid = New-Guid
ProductTargetArchitecture = $TargetArchitecture;
ProductTargetArchitecture = $TargetArchitecture
Force = $Force
}
if($pscmdlet.ShouldProcess("Create MSI Package"))
@ -146,6 +150,7 @@ function Start-PSPackage {
PackageSourcePath = $Source
PackageVersion = $Version
AssetsPath = "$PSScriptRoot\..\..\assets"
Force = $Force
}
New-AppxPackage @Arguments
}
@ -161,12 +166,28 @@ function Start-PSPackage {
Write-Warning "Ignoring AppImage type for non Ubuntu Trusty platform"
}
}
'nupkg' {
$Arguments = @{
PackageNameSuffix = $NameSuffix
PackageSourcePath = $Source
PackageVersion = $Version
PackageRuntime = $Runtime
PackageConfiguration = $Configuration
Force = $Force
}
if($pscmdlet.ShouldProcess("Create NuPkg Package"))
{
New-NugetPackage @Arguments
}
}
default {
$Arguments = @{
Type = $_
PackageSourcePath = $Source
Name = $Name
Version = $Version
Force = $Force
}
if($pscmdlet.ShouldProcess("Create $_ Package"))
@ -197,7 +218,10 @@ function New-UnixPackage {
# Package iteration version (rarely changed)
# This is a string because strings are appended to it
[string]$Iteration = "1"
[string]$Iteration = "1",
[Switch]
$Force
)
# Validate platform
@ -259,25 +283,8 @@ function New-UnixPackage {
# Setup staging directory so we don't change the original source directory
$Staging = "$PSScriptRoot/staging"
if($pscmdlet.ShouldProcess("Create staging folder"))
{
Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $Staging
Copy-Item -Recurse $PackageSourcePath $Staging
# Rename files to given name if not "powershell"
if ($Name -ne "powershell") {
$Files = @("powershell",
"powershell.dll",
"powershell.deps.json",
"powershell.pdb",
"powershell.runtimeconfig.json",
"powershell.xml")
foreach ($File in $Files) {
$NewName = $File -replace "^powershell", $Name
Move-Item "$Staging/$File" "$Staging/$NewName"
}
}
if ($pscmdlet.ShouldProcess("Create staging folder")) {
New-StagingFolder -StagingPath $Staging -Name $Name
}
# Follow the Filesystem Hierarchy Standard for Linux and OS X
@ -497,13 +504,46 @@ function New-UnixPackage {
$newPackageName = "{0}-{1}{2}" -f $packageNameWithoutExt, $script:Options.Runtime, $packageExt
$newPackagePath = Join-Path $createdPackage.DirectoryName $newPackageName
$createdPackage = Rename-Item $createdPackage.FullName $newPackagePath -PassThru
$createdPackage = Rename-Item $createdPackage.FullName $newPackagePath -PassThru -Force:$Force
}
}
return $createdPackage
}
function New-StagingFolder
{
param(
[Parameter(Mandatory)]
[string]
$StagingPath,
# Must start with 'powershell' but may have any suffix
[Parameter(Mandatory)]
[ValidatePattern("^powershell")]
[string]
$Name
)
Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $StagingPath
Copy-Item -Recurse $PackageSourcePath $StagingPath
# Rename files to given name if not "powershell"
if ($Name -ne "powershell") {
$Files = @("powershell",
"powershell.dll",
"powershell.deps.json",
"powershell.pdb",
"powershell.runtimeconfig.json",
"powershell.xml")
foreach ($File in $Files) {
$NewName = $File -replace "^powershell", $Name
Move-Item "$StagingPath/$File" "$StagingPath/$NewName"
}
}
}
# Function to create a zip file for Nano Server and xcopy deployment
function New-ZipPackage
{
@ -539,6 +579,14 @@ function New-ZipPackage
$zipLocationPath = Join-Path $PWD "$zipPackageName.zip"
if($Force.IsPresent)
{
if(Test-Path $zipLocationPath)
{
Remove-Item $zipLocationPath
}
}
If(Get-Command Compress-Archive -ErrorAction Ignore)
{
if($pscmdlet.ShouldProcess("Create zip package"))
@ -546,7 +594,7 @@ function New-ZipPackage
Compress-Archive -Path $PackageSourcePath\* -DestinationPath $zipLocationPath
}
Write-Verbose "You can find the Zip @ $zipLocationPath" -Verbose
log "You can find the Zip @ $zipLocationPath"
$zipLocationPath
}
@ -556,3 +604,192 @@ function New-ZipPackage
Write-Error -Message "Compress-Archive cmdlet is missing in this PowerShell version"
}
}
function New-NugetPackage
{
[CmdletBinding(SupportsShouldProcess=$true)]
param (
# Name of the Product
[ValidateNotNullOrEmpty()]
[string] $PackageName = 'PowerShell',
# Suffix of the Name
[string] $PackageNameSuffix,
# Version of the Product
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageVersion,
# Runtime of the Product
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageRuntime,
# Configuration of the Product
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageConfiguration,
# Source Path to the Product Files - required to package the contents into an Zip
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageSourcePath,
[Switch]
$Force
)
log "PackageVersion: $PackageVersion"
$nugetSemanticVersion = Get-NugetSemanticVersion -Version $PackageVersion
log "nugetSemanticVersion: $nugetSemanticVersion"
$nugetFolder = New-SubFolder -Path $PSScriptRoot -ChildPath 'nugetOutput' -Clean
# Setup staging directory so we don't change the original source directory
$stagingRoot = New-SubFolder -Path $PSScriptRoot -ChildPath 'nugetStaging' -Clean
$contentFolder = Join-Path -path $stagingRoot -ChildPath 'content'
if ($pscmdlet.ShouldProcess("Create staging folder")) {
New-StagingFolder -StagingPath $contentFolder -Name $Name
}
$projectFolder = Join-Path $PSScriptRoot -ChildPath 'project'
$arguments = @('pack')
$arguments += @('--output',$nugetFolder)
$arguments += @('--configuration',$PackageConfiguration)
$arguments += @('--runtime',$PackageRuntime)
$arguments += "/p:StagingPath=$stagingRoot"
$arguments += "/p:RID=$PackageRuntime"
$arguments += "/p:SemVer=$nugetSemanticVersion"
$arguments += $projectFolder
log "Running dotnet $arguments"
log "Use -verbose to see output..."
Start-NativeExecution -sb {dotnet $arguments} | Foreach-Object {Write-Verbose $_}
Get-ChildItem $nugetFolder\* | Select-Object -ExpandProperty FullName
}
function New-SubFolder
{
[CmdletBinding(SupportsShouldProcess=$true)]
param(
[string]
$Path,
[String]
$ChildPath,
[switch]
$Clean
)
$subFolderPath = Join-Path -Path $Path -ChildPath $ChildPath
if($Clean.IsPresent -and (Test-Path $subFolderPath))
{
Remove-Item -Path $subFolderPath -Recurse -Force -ErrorAction SilentlyContinue
}
if(!(Test-Path $subFolderPath))
{
$null = New-Item -Path $subFolderPath -ItemType Directory
}
return $subFolderPath
}
# Builds coming out of this project can have version number as 'a.b.c-stringf.d-e-f' OR 'a.b.c.d-e-f'
# This function converts the above version into semantic version major.minor[.build-quality[.revision]] format
function Get-PackageSemanticVersion
{
[CmdletBinding()]
param (
# Version of the Package
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $Version,
[switch] $NuGet
)
Write-Verbose "Extract the semantic version in the form of major.minor[.build-quality[.revision]] for $Version"
$packageVersionTokens = $Version.Split('.')
if (3 -eq $packageVersionTokens.Count) {
# In case the input is of the form a.b.c, add a '0' at the end for revision field
$packageSemanticVersion = $Version,'0' -join '.'
} elseif (3 -lt $packageVersionTokens.Count) {
# We have all the four fields
$packageRevisionTokens = ($packageVersionTokens[3].Split('-'))[0]
if($NuGet.IsPresent)
{
$packageRevisionTokens = $packageRevisionTokens.Replace('.','-')
}
$packageSemanticVersion = $packageVersionTokens[0],$packageVersionTokens[1],$packageVersionTokens[2],$packageRevisionTokens -join '.'
} else {
throw "Cannot create Semantic Version from the string $Version containing 4 or more tokens"
}
$packageSemanticVersion
}
# Builds coming out of this project can have version number as 'a.b.c-stringf.d-e-f' OR 'a.b.c.d-e-f'
# This function converts the above version into semantic version major.minor[.build-quality[-revision]] format needed for nuget
function Get-NugetSemanticVersion
{
[CmdletBinding()]
param (
# Version of the Package
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $Version
)
$packageVersionTokens = $Version.Split('.')
Write-Verbose "Extract the semantic version in the form of major.minor[.build-quality[-revision]] for $Version"
$versionPartTokens = @()
$identifierPortionTokens = @()
$inIdentifier = $false
foreach($token in $packageVersionTokens) {
$tokenParts = $null
if($token -match '-') {
$tokenParts = $token.Split('-')
}
elseif($inIdentifier) {
$tokenParts = @($token)
}
# If we don't have token parts, then it's a versionPart
if(!$tokenParts) {
$versionPartTokens += $token
}
else {
foreach($idToken in $tokenParts) {
# The first token after we detect the id Part is still
# a version part
if(!$inIdentifier) {
$versionPartTokens += $idToken
$inIdentifier = $true
}
else {
$identifierPortionTokens += $idToken
}
}
}
}
if($versionPartTokens.Count -gt 3) {
throw "Cannot create Semantic Version from the string $Version containing 4 or more version tokens"
}
$packageSemanticVersion = ($versionPartTokens -join '.')
if($identifierPortionTokens.Count -gt 0) {
$packageSemanticVersion += '-' + ($identifierPortionTokens -join '-')
}
$packageSemanticVersion
}

16
tools/packaging/project/package.csproj Normal file
View file

@ -0,0 +1,16 @@
<Project Sdk="Microsoft.NET.Sdk">
<!--
Due to https://github.com/dotnet/sdk/issues/1021
When packaging we must build something.
So, we are building an empty assembly called NotUsed, and discarding it.
-->
<PropertyGroup>
<AssemblyName>NotUsed</AssemblyName>
<Description>PowerShell Core nuget package with .NET CLI host including everything needed to run it.</Description>
<NuspecFile>powershell.nuspec</NuspecFile>
<NuspecProperties>runtime=$(RID);version=$(SemVer)</NuspecProperties>
<NuspecBasePath>$(StagingPath)</NuspecBasePath>
<IsTool>True</IsTool>
<TargetFramework>netcoreapp2.0</TargetFramework>
</PropertyGroup>
</Project>

21
tools/packaging/project/powershell.nuspec Normal file
View file

@ -0,0 +1,21 @@
<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
<metadata>
<id>powershell-$runtime$</id>
<version>$version$</version>
<title>PowerShell Core for $runtime$</title>
<authors>PowerShell</authors>
<owners>PowerShell</owners>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<licenseUrl>https://github.com/PowerShell/PowerShell/blob/master/LICENSE.txt</licenseUrl>
<projectUrl>https://github.com/powershell/powershell</projectUrl>
<iconUrl>https://github.com/PowerShell/PowerShell/blob/master/assets/Powershell_64.png</iconUrl>
<description>This package contains the PowerShell Core for $runtime$.</description>
<copyright>Copyright © Microsoft Corporation</copyright>
<tags>PowerShell</tags>
<contentFiles>
<files include="**" buildAction="None" copyToOutput="true" flatten="false"/>
</contentFiles>
</metadata>
</package>

24
tools/travis.ps1
View file

@ -1,7 +1,6 @@
param(
[switch]$Bootstrap
)
Import-Module $PSScriptRoot/../build.psm1 -Force
Import-Module $PSScriptRoot/packaging -Force
@ -117,10 +116,13 @@ $isFullBuild = $env:TRAVIS_EVENT_TYPE -eq 'cron' -or $env:TRAVIS_EVENT_TYPE -eq
if($Bootstrap.IsPresent)
{
Write-Host -Foreground Green "Executing travis.ps1 -BootStrap `$isPR='$isPr' - $commitMessage"
# Make sure we have all the tags
Sync-PSTags -AddRemoteIfMissing
Start-PSBootstrap -Package:(-not $isPr)
}
else
{
$BaseVersion = (Get-PSVersion -OmitCommitId) + '-'
Write-Host -Foreground Green "Executing travis.ps1 `$isPR='$isPr' `$isFullBuild='$isFullBuild' - $commitMessage"
$output = Split-Path -Parent (Get-PSOutput -Options (New-PSOptions))
@ -167,9 +169,25 @@ else
# Run 'CrossGen' for push commit, so that we can generate package.
# It won't rebuild powershell, but only CrossGen the already built assemblies.
if (-not $isFullBuild) { Start-PSBuild -CrossGen }
$packageParams = @{}
if($env:TRAVIS_BUILD_NUMBER)
{
$version = $BaseVersion + $env:TRAVIS_BUILD_NUMBER
$packageParams += @{Version=$version}
}
# Only build packages for branches, not pull requests
Start-PSPackage
Start-PSPackage -Type AppImage
$packages = @(Start-PSPackage @packageParams)
$packages += Start-PSPackage @packageParams -Type AppImage
foreach($package in $packages)
{
if($env:NUGET_KEY -and $env:NUGET_URL -and [system.io.path]::GetExtension($package) -ieq '.nupkg')
{
log "pushing $package to $env:NUGET_URL"
Start-NativeExecution -sb {dotnet nuget push $package --api-key $env:NUGET_KEY --source "$env:NUGET_URL/api/v2/package"} -IgnoreExitcode
}
}
try {
# this throws if there was an error
Test-PSPesterResults