PowerShell/build.psm1

3252 lines
114 KiB
PowerShell
Raw Normal View History

# Use the .NET Core APIs to determine the current platform; if a runtime
# exception is thrown, we are on FullCLR, not .NET Core.
try {
$Runtime = [System.Runtime.InteropServices.RuntimeInformation]
$OSPlatform = [System.Runtime.InteropServices.OSPlatform]
2016-07-22 01:52:22 +02:00
$IsCoreCLR = $true
$IsLinux = $Runtime::IsOSPlatform($OSPlatform::Linux)
$IsOSX = $Runtime::IsOSPlatform($OSPlatform::OSX)
$IsWindows = $Runtime::IsOSPlatform($OSPlatform::Windows)
} catch {
# If these are already set, then they're read-only and we're done
try {
2016-07-22 01:52:22 +02:00
$IsCoreCLR = $false
$IsLinux = $false
$IsOSX = $false
$IsWindows = $true
}
catch { }
}
$dotnetCLIChannel = "preview"
$dotnetCLIRequiredVersion = "2.0.0-preview2-006502"
# On Unix paths is separated by colon
# On Windows paths is separated by semicolon
$TestModulePathSeparator = ':'
if ($IsWindows)
{
$TestModulePathSeparator = ';'
$IsAdmin = (New-Object Security.Principal.WindowsPrincipal ([Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)
2017-01-17 22:00:52 +01:00
# Can't use $env:HOME - not available on older systems (e.g. in AppVeyor)
$nugetPackagesRoot = "${env:HOMEDRIVE}${env:HOMEPATH}\.nuget\packages"
}
else
{
$nugetPackagesRoot = "${env:HOME}/.nuget/packages"
}
2016-06-20 20:39:39 +02:00
if ($IsLinux) {
$LinuxInfo = Get-Content /etc/os-release -Raw | ConvertFrom-StringData
2016-08-11 22:38:35 +02:00
$IsUbuntu = $LinuxInfo.ID -match 'ubuntu'
$IsUbuntu14 = $IsUbuntu -and $LinuxInfo.VERSION_ID -match '14.04'
$IsUbuntu16 = $IsUbuntu -and $LinuxInfo.VERSION_ID -match '16.04'
$IsCentOS = $LinuxInfo.ID -match 'centos' -and $LinuxInfo.VERSION_ID -match '7'
$IsFedora = $LinuxInfo.ID -match 'fedora' -and $LinuxInfo.VERSION_ID -ge 24
$IsOpenSUSE = $LinuxInfo.ID -match 'opensuse'
$IsOpenSUSE13 = $IsOpenSUSE -and $LinuxInfo.VERSION_ID -match '13'
${IsOpenSUSE42.1} = $IsOpenSUSE -and $LinuxInfo.VERSION_ID -match '42.1'
$IsRedHatFamily = $IsCentOS -or $IsFedora -or $IsOpenSUSE
# Workaround for temporary LD_LIBRARY_PATH hack for Fedora 24
2017-01-12 22:24:11 +01:00
# https://github.com/PowerShell/PowerShell/issues/2511
if ($IsFedora -and (Test-Path ENV:\LD_LIBRARY_PATH)) {
Remove-Item -Force ENV:\LD_LIBRARY_PATH
Get-ChildItem ENV:
}
2016-06-20 20:39:39 +02:00
}
# Autoload (in current session) temporary modules used in our tests
$TestModulePath = Join-Path $PSScriptRoot "test/tools/Modules"
2017-03-29 19:11:02 +02:00
if ( $env:PSModulePath -notcontains $TestModulePath ) {
$env:PSModulePath = $TestModulePath+$TestModulePathSeparator+$($env:PSModulePath)
}
#
2017-01-16 22:31:14 +01:00
# At the moment, we just support x64 builds. When we support x86 builds, this
# check may need to verify the SDK for the specified architecture.
#
function Get-Win10SDKBinDir {
return "${env:ProgramFiles(x86)}\Windows Kits\10\bin\x64"
}
function Test-Win10SDK {
# The Windows 10 SDK is installed to "${env:ProgramFiles(x86)}\Windows Kits\10\bin\x64",
# but the directory may exist even if the SDK has not been installed.
#
# A slightly more robust check is for the mc.exe binary within that directory.
# It is only present if the SDK is installed.
return (Test-Path "${env:ProgramFiles(x86)}\Windows Kits\10\bin\x64\mc.exe")
}
2016-04-02 07:01:05 +02:00
2016-04-01 23:41:13 +02:00
function Start-PSBuild {
[CmdletBinding(DefaultParameterSetName='CoreCLR')]
param(
# When specified this switch will stops running dev powershell
# to help avoid compilation error, because file are in use.
[switch]$StopDevPowerShell,
[switch]$Restore,
[string]$Output,
[switch]$ResGen,
[switch]$TypeGen,
[switch]$Clean,
[switch]$PSModuleRestore,
Spelling comments (#2066) * spelling: comments in src/Microsoft.Management.Infrastructure.CimCmdlets * spelling: comments in src/Microsoft.PackageManagement.ArchiverProviders * spelling: comments in src/Microsoft.PackageManagement.CoreProviders * spelling: comments in src/Microsoft.PackageManagement.MetaProvider.PowerShell * spelling: comments in src/Microsoft.PackageManagement.MsiProvider * spelling: comments in src/Microsoft.PackageManagement.MsuProvider * spelling: comments in src/Microsoft.PackageManagement.NuGetProvider * spelling: comments in src/Microsoft.PackageManagement.PackageSourceListProvider * spelling: comments in src/Microsoft.PackageManagement * spelling: comments in src/Microsoft.PowerShell.Activities * spelling: comments in src/Microsoft.PowerShell.Commands.Diagnostics * spelling: comments in src/Microsoft.PowerShell.Commands.Management * spelling: comments in src/Microsoft.PowerShell.Commands.Utility * spelling: comments in src/Microsoft.PowerShell.ConsoleHost * spelling: comments in src/Microsoft.PowerShell.Core.Activities * spelling: comments in src/Microsoft.PowerShell.CoreCLR.AssemblyLoadContext * spelling: comments in src/Microsoft.PowerShell.CoreCLR.Eventing * spelling: comments in src/Microsoft.PowerShell.Diagnostics.Activities * spelling: comments in src/Microsoft.PowerShell.GraphicalHost * spelling: comments in src/Microsoft.PowerShell.LocalAccounts * spelling: comments in src/Microsoft.PowerShell.Management.Activities * spelling: comments in src/Microsoft.PowerShell.PSReadLine * spelling: comments in src/Microsoft.PowerShell.PackageManagement * spelling: comments in src/Microsoft.PowerShell.ScheduledJob * spelling: comments in src/Microsoft.PowerShell.Security.Activities * spelling: comments in src/Microsoft.PowerShell.Security * spelling: comments in src/Microsoft.PowerShell.Utility.Activities * spelling: comments in src/Microsoft.PowerShell.Workflow.ServiceCore * spelling: comments in src/Microsoft.WSMan.Management.Activities * spelling: comments in src/Modules * spelling: comments in src/Schemas * spelling: comments in src/libpsl-native * spelling: comments in src/powershell-native * spelling: comments in build.psm1 * spelling: comments in src/System.Management.Automation/CoreCLR * spelling: comments in src/System.Management.Automation/DscSupport * spelling: comments in src/System.Management.Automation/cimSupport * spelling: comments in src/System.Management.Automation/commands * spelling: comments in src/System.Management.Automation/engine/Modules
2016-08-26 22:46:03 +02:00
# 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,
2016-03-04 00:54:52 +01:00
# These runtimes must match those in project.json
# We do not use ValidateScript since we want tab completion
[ValidateSet("ubuntu.14.04-x64",
2016-08-02 00:18:42 +02:00
"ubuntu.16.04-x64",
2016-06-03 05:13:30 +02:00
"debian.8-x64",
"centos.7-x64",
"fedora.24-x64",
2016-03-04 00:54:52 +01:00
"win7-x64",
"win7-x86",
"win81-x64",
2016-03-04 00:54:52 +01:00
"win10-x64",
"osx.10.11-x64",
"osx.10.12-x64",
"opensuse.13.2-x64",
"opensuse.42.1-x64")]
[Parameter(ParameterSetName='CoreCLR')]
[string]$Runtime,
[Parameter(ParameterSetName='FullCLR', Mandatory=$true)]
[switch]$FullCLR,
[Parameter(ParameterSetName='FullCLR')]
[switch]$XamlGen,
Add OpenCover PS Module to collect code coverage (#2585) * Add OpenCover PS Module to collect code coverage OpenCover PS Module helps is collecting Code Coverage using the OpenCover toolset. The module helps in comparing two code coverage runs as well. * Change OpenCover.psd1 to ASCII * Fix an error in path for OpenCover Fixed an error on path for OpenCover. Also used ZipFile class instead of cmdlet as it might not be available on CI system. * Convert module to be Powershell v4 compliant Changed implementation from classes to PSObjects and implemented Expand-ZipArchive. * Added CodeCoverage as a configuration to project.json files Added CodeCoverage as the new configuration for all the project.json files. When Start-PSBuild is executed with configuration as CodeCoverage, we change the degubType to 'full' as required by OpenCover toolset. Also made changes to appveyor.psm1 to build a CodeCoverage package on daily builds and publish it as a zip. * Addressed code review comments Changed from Add-Member to use pscustomobject type accelator. Removed [gc]::collect. * Added explicit garbage collection * Addressed code review comments - Make sure that the build Start-PSPackage gets is not a code coverage build - Add debugType = full for FullCLR - Remove configurations from PackageManagement files as it is not needed. - Build CodeCoverage build first in AppVeyor. * Resolve merge conflict * Fix indentation * Fix newline at end of file * Added command discovery for locating OpenCover.console.exe
2016-11-11 20:12:07 +01:00
[ValidateSet('Linux', 'Debug', 'Release', 'CodeCoverage', '')] # We might need "Checked" as well
[string]$Configuration,
2016-08-03 09:19:39 +02:00
[Parameter(ParameterSetName='CoreCLR')]
[switch]$Publish,
2016-08-03 09:19:39 +02:00
[Parameter(ParameterSetName='CoreCLR')]
[switch]$CrossGen,
[Parameter(ParameterSetName='CoreCLR')]
[ValidatePattern("^v\d+\.\d+\.\d+(-\w+\.\d+)?$")]
[ValidateNotNullOrEmpty()]
[string]$ReleaseTag
)
function Stop-DevPowerShell {
Get-Process powershell* |
Where-Object {
$_.Modules |
Where-Object {
$_.FileName -eq (Resolve-Path $script:Options.Output).Path
}
} |
Stop-Process -Verbose
}
if ($Clean) {
log "Cleaning your working directory. You can also do it with 'git clean -fdX'"
Push-Location $PSScriptRoot
try {
git clean -fdX
2017-01-16 22:31:14 +01:00
# Extra cleaning is required to delete the CMake temporary files.
# These are not cleaned when using "X" and cause CMake to retain state, leading to
# mis-configured environment issues when switching between x86 and x64 compilation
# environments.
git clean -fdx .\src\powershell-native
} finally {
Pop-Location
}
}
# save git commit id to file for PowerShell to include in PSVersionTable
$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 > "$psscriptroot/powershell.version"
# create the telemetry flag file
$null = new-item -force -type file "$psscriptroot/DELETE_ME_TO_DISABLE_CONSOLEHOST_TELEMETRY"
# simplify ParameterSetNames
2016-04-01 23:41:13 +02:00
if ($PSCmdlet.ParameterSetName -eq 'FullCLR') {
$FullCLR = $true
2017-03-23 21:04:52 +01:00
## Stop building 'FullCLR', but keep the parameters and related scripts for now.
## Once we confirm that portable modules is supported with .NET Core 2.0, we will clean up all FullCLR related scripts.
throw "Building against FullCLR is not supported"
}
# Add .NET CLI tools to PATH
Find-Dotnet
2016-08-05 01:15:49 +02:00
# verify we have all tools in place to do the build
$precheck = precheck 'dotnet' "Build dependency 'dotnet' not found in PATH. Run Start-PSBootstrap. Also see: https://dotnet.github.io/getting-started/"
$dotnetCLIInstalledVersion = (dotnet --version)
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 osx and linux '`$env:HOME/.dotnet'
2. Run Start-PSBootstrap or Install-Dotnet
3. Start-PSBuild -Clean
`n
"@
return
}
if ($IsWindows) {
# cmake is needed to build powershell.exe
$precheck = $precheck -and (precheck 'cmake' 'cmake not found. Run "Start-PSBootstrap -BuildNative". You can also install it from https://chocolatey.org/packages/cmake')
2016-04-01 23:41:13 +02:00
Use-MSBuild
2016-06-17 01:43:51 +02:00
#mc.exe is Message Compiler for native resources
if (-Not (Test-Win10SDK)) {
throw 'Win 10 SDK not found. Run Start-PSBootstrap or install Microsoft Windows 10 SDK from https://developer.microsoft.com/en-US/windows/downloads/windows-10-sdk'
2016-06-17 01:43:51 +02:00
}
$vcPath = (Get-Item(Join-Path -Path "$env:VS140COMNTOOLS" -ChildPath '../../vc')).FullName
$atlMfcIncludePath = Join-Path -Path $vcPath -ChildPath 'atlmfc/include'
# atlbase.h is included in the pwrshplugin project
if ((Test-Path -Path $atlMfcIncludePath\atlbase.h) -eq $false) {
throw "Could not find Visual Studio include file atlbase.h at $atlMfcIncludePath. Please ensure the optional feature 'Microsoft Foundation Classes for C++' is installed."
}
# vcvarsall.bat is used to setup environment variables
if ((Test-Path -Path $vcPath\vcvarsall.bat) -eq $false) {
throw "Could not find Visual Studio vcvarsall.bat at $vcPath. Please ensure the optional feature 'Common Tools for Visual C++' is installed."
}
# setup msbuild configuration
if ($Configuration -eq 'Debug' -or $Configuration -eq 'Release') {
$msbuildConfiguration = $Configuration
} else {
$msbuildConfiguration = 'Release'
}
} elseif ($IsLinux -or $IsOSX) {
foreach ($Dependency in 'cmake', 'make', 'g++') {
$precheck = $precheck -and (precheck $Dependency "Build dependency '$Dependency' not found. Run 'Start-PSBootstrap -BuildNative'.")
}
}
2016-04-01 23:41:13 +02:00
# Abort if any precheck failed
if (-not $precheck) {
return
}
# set output options
$OptionsArguments = @{
CrossGen=$CrossGen
Output=$Output
FullCLR=$FullCLR
Runtime=$Runtime
Configuration=$Configuration
Verbose=$true
SMAOnly=[bool]$SMAOnly
}
$script:Options = New-PSOptions @OptionsArguments
if ($StopDevPowerShell) {
Stop-DevPowerShell
}
# setup arguments
$Arguments = @("publish")
if ($Output) {
$Arguments += "--output", $Output
}
elseif ($SMAOnly) {
$Arguments += "--output", (Split-Path $script:Options.Output)
}
$Arguments += "--configuration", $Options.Configuration
$Arguments += "--framework", $Options.Framework
if (-not $SMAOnly) {
# libraries should not have runtime
$Arguments += "--runtime", $Options.Runtime
}
# handle Restore
2017-03-23 21:04:52 +01:00
if ($Restore -or -not (Test-Path "$($Options.Top)/obj/project.assets.json")) {
log "Run dotnet restore"
2017-03-23 21:04:52 +01:00
$srcProjectDirs = @($Options.Top, "$PSScriptRoot/src/TypeCatalogGen", "$PSScriptRoot/src/ResGen")
$testProjectDirs = Get-ChildItem "$PSScriptRoot/test/*.csproj" -Recurse | % { [System.IO.Path]::GetDirectoryName($_) }
$RestoreArguments = @("--verbosity")
if ($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent) {
2017-03-23 21:04:52 +01:00
$RestoreArguments += "detailed"
} else {
2017-03-23 21:04:52 +01:00
$RestoreArguments += "quiet"
}
2017-03-23 21:04:52 +01:00
($srcProjectDirs + $testProjectDirs) | % { Start-NativeExecution { dotnet restore $_ $RestoreArguments } }
}
# handle ResGen
2016-06-17 16:51:32 +02:00
# Heuristic to run ResGen on the fresh machine
if ($ResGen -or -not (Test-Path "$PSScriptRoot/src/Microsoft.PowerShell.ConsoleHost/gen")) {
log "Run ResGen (generating C# bindings for resx files)"
Start-ResGen
}
# handle xaml files
# Heuristic to resolve xaml on the fresh machine
if ($FullCLR -and ($XamlGen -or -not (Test-Path "$PSScriptRoot/src/Microsoft.PowerShell.Activities/gen/*.g.cs"))) {
log "Run XamlGen (generating .g.cs and .resources for .xaml files)"
Start-XamlGen -MSBuildConfiguration $msbuildConfiguration
}
# Build native components
if (($IsLinux -or $IsOSX) -and -not $SMAOnly) {
$Ext = if ($IsLinux) {
"so"
} elseif ($IsOSX) {
"dylib"
}
$Native = "$PSScriptRoot/src/libpsl-native"
$Lib = "$($Options.Top)/libpsl-native.$Ext"
log "Start building $Lib"
try {
Push-Location $Native
Start-NativeExecution { cmake -DCMAKE_BUILD_TYPE=Debug . }
Start-NativeExecution { make -j }
Start-NativeExecution { ctest --verbose }
} finally {
Pop-Location
}
if (-not (Test-Path $Lib)) {
throw "Compilation of $Lib failed"
}
2016-08-05 01:15:49 +02:00
} elseif ($IsWindows -and (-not $SMAOnly)) {
log "Start building native Windows binaries"
2016-04-01 23:41:13 +02:00
try {
Push-Location "$PSScriptRoot\src\powershell-native"
2016-11-16 19:32:21 +01:00
$NativeHostArch = "x64"
if ($script:Options.Runtime -match "-x86")
{
$NativeHostArch = "x86"
}
# setup cmakeGenerator
if ($NativeHostArch -eq 'x86') {
$cmakeGenerator = 'Visual Studio 14 2015'
} else {
$cmakeGenerator = 'Visual Studio 14 2015 Win64'
}
2016-06-17 01:43:51 +02:00
# Compile native resources
$currentLocation = Get-Location
2016-06-17 01:43:51 +02:00
@("nativemsh/pwrshplugin") | % {
$nativeResourcesFolder = $_
Get-ChildItem $nativeResourcesFolder -Filter "*.mc" | % {
$command = @"
cmd.exe /C cd /d "$currentLocation" "&" "$($vcPath)\vcvarsall.bat" "$NativeHostArch" "&" mc.exe -o -d -c -U "$($_.FullName)" -h "$nativeResourcesFolder" -r "$nativeResourcesFolder"
"@
log " Executing mc.exe Command: $command"
2016-08-30 03:53:06 +02:00
Start-NativeExecution { Invoke-Expression -Command:$command 2>&1 }
2016-06-17 01:43:51 +02:00
}
}
2016-08-05 01:15:49 +02:00
function Build-NativeWindowsBinaries {
param(
# Describes wither it should build the CoreCLR or FullCLR version
[ValidateSet("ON", "OFF")]
[string]$OneCoreValue,
2017-01-16 22:31:14 +01:00
2016-08-05 01:15:49 +02:00
# Array of file names to copy from the local build directory to the packaging directory
[string[]]$FilesToCopy
)
# Disabling until I figure out if it is necessary
2016-08-05 01:15:49 +02:00
# $overrideFlags = "-DCMAKE_USER_MAKE_RULES_OVERRIDE=$PSScriptRoot\src\powershell-native\windows-compiler-override.txt"
$overrideFlags = ""
$location = Get-Location
$command = @"
cmd.exe /C cd /d "$location" "&" "$($vcPath)\vcvarsall.bat" "$NativeHostArch" "&" cmake "$overrideFlags" -DBUILD_ONECORE=$OneCoreValue -DBUILD_TARGET_ARCH=$NativeHostArch -G "$cmakeGenerator" . "&" msbuild ALL_BUILD.vcxproj "/p:Configuration=$msbuildConfiguration"
2016-07-07 20:34:10 +02:00
"@
log " Executing Build Command: $command"
Start-NativeExecution { Invoke-Expression -Command:$command }
2016-08-05 01:15:49 +02:00
$clrTarget = "FullClr"
if ($OneCoreValue -eq "ON")
{
$clrTarget = "CoreClr"
}
# Copy the binaries from the local build directory to the packaging directory
$dstPath = ($script:Options).Top
$FilesToCopy | % {
$srcPath = Join-Path (Join-Path (Join-Path (Get-Location) "bin") $msbuildConfiguration) "$clrTarget/$_"
log " Copying $srcPath to $dstPath"
Copy-Item $srcPath $dstPath
}
}
2017-01-16 22:31:14 +01:00
2016-08-05 01:15:49 +02:00
if ($FullCLR) {
2017-01-16 22:31:14 +01:00
$fullBinaries = @(
2016-08-05 01:15:49 +02:00
'powershell.exe',
'powershell.pdb',
'pwrshplugin.dll',
'pwrshplugin.pdb'
)
2017-01-16 22:31:14 +01:00
Build-NativeWindowsBinaries "OFF" $fullBinaries
2016-08-05 01:15:49 +02:00
}
else
{
2017-01-16 22:31:14 +01:00
$coreClrBinaries = @(
2016-08-05 01:15:49 +02:00
'pwrshplugin.dll',
'pwrshplugin.pdb'
)
Build-NativeWindowsBinaries "ON" $coreClrBinaries
# Place the remoting configuration script in the same directory
# as the binary so it will get published.
Copy-Item .\Install-PowerShellRemoting.ps1 ($script:Options).Top
}
2016-04-01 23:41:13 +02:00
} finally {
Pop-Location
}
}
# handle TypeGen
if ($TypeGen -or -not (Test-Path "$PSScriptRoot/src/Microsoft.PowerShell.CoreCLR.AssemblyLoadContext/CorePsTypeCatalog.cs")) {
log "Run TypeGen (generating CorePsTypeCatalog.cs)"
Start-TypeGen
}
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
# Get the folder path where powershell.exe is located.
$publishPath = Split-Path $Options.Output -Parent
2016-04-01 23:41:13 +02:00
try {
# Relative paths do not work well if cwd is not changed to project
Push-Location $Options.Top
2016-04-20 01:39:06 +02:00
log "Run dotnet $Arguments from $pwd"
Start-NativeExecution { dotnet $Arguments }
if ($CrossGen) {
2016-11-20 21:59:50 +01:00
Start-CrossGen -PublishPath $publishPath -Runtime $script:Options.Runtime
log "PowerShell.exe with ngen binaries is available at: $($Options.Output)"
} else {
log "PowerShell output: $($Options.Output)"
}
2016-04-01 23:41:13 +02:00
} finally {
Pop-Location
}
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
# add 'x' permission when building the standalone application
# this is temporary workaround to a bug in dotnet.exe, tracking by dotnet/cli issue #6286
if ($Options.Configuration -eq "Linux") {
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
chmod u+x $Options.Output
}
# publish netcoreapp2.0 reference assemblies
try {
Push-Location "$PSScriptRoot/src/TypeCatalogGen"
$refAssemblies = Get-Content -Path "powershell.inc" | ? { $_ -like "*microsoft.netcore.app*" } | % { $_.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
}
# copy PowerShell host profile if Windows
if ($IsWindows)
{
Copy-Item -Path "$PSScriptRoot/src/powershell-win-core/Microsoft.PowerShell_profile.ps1" -Destination $publishPath -Force
}
if ($IsRedHatFamily) {
# 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 OSX builds for itself
# against the correct versions.
if ( ! (test-path "$publishPath/libssl.so.1.0.0")) {
$null = New-Item -Force -ItemType SymbolicLink -Target "/lib64/libssl.so.10" -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 "/lib64/libcrypto.so.10" -Path "$publishPath/libcrypto.so.1.0.0" -ErrorAction Stop
}
}
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
# download modules from powershell gallery.
# - PowerShellGet, PackageManagement, Microsoft.PowerShell.Archive
if($PSModuleRestore)
{
Jameswtruher/travisdailybuild (#2958) * Stifle progress output in build.psm1 for some operations Modify test failure presentation to use platform available XML methods * Add timeout support for returning runtime parsing errors Some of the language/parser tests have been hanging in a non-reproducable manner which causes the CI system to invalidate the entire run. This change adds support for timeout which will fail a test if it runs to long, rather than invalidate the entire run. current behavior is still supported, and is not done in a new session: PS> get-runtimeerror -src '1/' At line:1 char:3 + 1/ + ~ You must provide a value expression following the '/' operator. + CategoryInfo : ParserError: (:) [], ParentContainsErrorRecordException + FullyQualifiedErrorId : ExpectedValueExpression Adding a timeout will do the operation in a async powershell session PS> get-runtimeerror -src '1/' -timeout 5 You must provide a value expression following the '/' operator. + CategoryInfo : ParserError: (:) [], ParentContainsErrorRecordException + FullyQualifiedErrorId : ExpectedValueExpression If the operation takes longer than the supplied timeout, a timeout error will be returned PS> get-runtimeerror -src 'start-sleep 6' -timeout 2 get-runtimeerror : Operation Timed Out ('start-sleep 6') At line:1 char:1 + get-runtimeerror -src 'start-sleep 6' -timeout 2 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : NotSpecified: (:) [Write-Error], WriteErrorException + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-RuntimeError * Modify native linux command tests to skip on Windows and pending on Mac * remove verbose and progress output from help tests * Be sure that Feature Counter tests only run on Windows Also, only call add-type in CounterTestHelperFunctions.ps1 if we're going to actually run the tests * do not run any get-computerinfo tests on non-windows systems * suppress progress output from PowerShell Get tests * remove -quiet from API and CRON Builds Travis watches output from the build to ensure that it hasn't hung we need to find a balance between too much output and not enough output. A run which has too much output is killed because it looks like an error loop A run which has too little output is killed because it looks like a hang * Remove commented line in Import-Counter.Tests.ps1 Remove extraneous extra line in PowerShellGet.Tests.ps1 * Change `-as "type"` to `-as [type]` in build.psm1 Alter timeout to 10 seconds to be improve chances of not timing out for runtime parser checks improve logic for counter tests to also skip for IoT * use the existing function of SkipCounterTests rather than duplicate the logic in import-counter.tests.ps1
2017-01-10 23:42:27 +01:00
$ProgressPreference = "SilentlyContinue"
2017-01-16 22:31:14 +01:00
log "Restore PowerShell modules to $publishPath"
$modulesDir = Join-Path -Path $publishPath -ChildPath "Modules"
# Restore modules from myget feed
Restore-PSModule -Destination $modulesDir -Name @(
# PowerShellGet depends on PackageManagement module, so PackageManagement module will be installed with the PowerShellGet module.
'PowerShellGet'
)
# Restore modules from powershellgallery feed
Restore-PSModule -Destination $modulesDir -Name @(
'Microsoft.PowerShell.Archive'
) -SourceLocation "https://www.powershellgallery.com/api/v2/"
}
}
function Compress-TestContent {
[CmdletBinding()]
param(
$Destination
)
Publish-PSTestTools
$powerShellTestRoot = Join-Path $PSScriptRoot 'test'
Add-Type -AssemblyName System.IO.Compression.FileSystem
$resolvedPath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($Destination)
2017-01-16 22:31:14 +01:00
[System.IO.Compression.ZipFile]::CreateFromDirectory($powerShellTestRoot, $resolvedPath)
}
function New-PSOptions {
[CmdletBinding()]
param(
Add OpenCover PS Module to collect code coverage (#2585) * Add OpenCover PS Module to collect code coverage OpenCover PS Module helps is collecting Code Coverage using the OpenCover toolset. The module helps in comparing two code coverage runs as well. * Change OpenCover.psd1 to ASCII * Fix an error in path for OpenCover Fixed an error on path for OpenCover. Also used ZipFile class instead of cmdlet as it might not be available on CI system. * Convert module to be Powershell v4 compliant Changed implementation from classes to PSObjects and implemented Expand-ZipArchive. * Added CodeCoverage as a configuration to project.json files Added CodeCoverage as the new configuration for all the project.json files. When Start-PSBuild is executed with configuration as CodeCoverage, we change the degubType to 'full' as required by OpenCover toolset. Also made changes to appveyor.psm1 to build a CodeCoverage package on daily builds and publish it as a zip. * Addressed code review comments Changed from Add-Member to use pscustomobject type accelator. Removed [gc]::collect. * Added explicit garbage collection * Addressed code review comments - Make sure that the build Start-PSPackage gets is not a code coverage build - Add debugType = full for FullCLR - Remove configurations from PackageManagement files as it is not needed. - Build CodeCoverage build first in AppVeyor. * Resolve merge conflict * Fix indentation * Fix newline at end of file * Added command discovery for locating OpenCover.console.exe
2016-11-11 20:12:07 +01:00
[ValidateSet("Linux", "Debug", "Release", "CodeCoverage", "")]
[string]$Configuration,
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
[ValidateSet("netcoreapp2.0", "net451")]
[string]$Framework,
# These are duplicated from Start-PSBuild
# We do not use ValidateScript since we want tab completion
[ValidateSet("",
"ubuntu.14.04-x64",
2016-08-02 00:18:42 +02:00
"ubuntu.16.04-x64",
2016-06-03 05:13:30 +02:00
"debian.8-x64",
"centos.7-x64",
"fedora.24-x64",
2016-11-15 19:14:31 +01:00
"win7-x86",
"win7-x64",
"win81-x64",
"win10-x64",
"osx.10.11-x64",
"osx.10.12-x64",
"opensuse.13.2-x64",
"opensuse.42.1-x64")]
[string]$Runtime,
[switch]$CrossGen,
[string]$Output,
[switch]$FullCLR,
[switch]$SMAOnly
)
# Add .NET CLI tools to PATH
Find-Dotnet
2017-03-23 21:04:52 +01:00
if ($FullCLR) {
## Stop building 'FullCLR', but keep the parameters and related scripts for now.
## Once we confirm that portable modules is supported with .NET Core 2.0, we will clean up all FullCLR related scripts.
throw "Building against FullCLR is not supported"
}
$ConfigWarningMsg = "The passed-in Configuration value '{0}' is not supported on '{1}'. Use '{2}' instead."
if (-not $Configuration) {
$Configuration = if ($IsLinux -or $IsOSX) {
"Linux"
} elseif ($IsWindows) {
"Debug"
}
} else {
switch ($Configuration) {
"Linux" {
if ($IsWindows) {
$Configuration = "Debug"
Write-Warning ($ConfigWarningMsg -f $switch.Current, "Windows", $Configuration)
}
}
Add OpenCover PS Module to collect code coverage (#2585) * Add OpenCover PS Module to collect code coverage OpenCover PS Module helps is collecting Code Coverage using the OpenCover toolset. The module helps in comparing two code coverage runs as well. * Change OpenCover.psd1 to ASCII * Fix an error in path for OpenCover Fixed an error on path for OpenCover. Also used ZipFile class instead of cmdlet as it might not be available on CI system. * Convert module to be Powershell v4 compliant Changed implementation from classes to PSObjects and implemented Expand-ZipArchive. * Added CodeCoverage as a configuration to project.json files Added CodeCoverage as the new configuration for all the project.json files. When Start-PSBuild is executed with configuration as CodeCoverage, we change the degubType to 'full' as required by OpenCover toolset. Also made changes to appveyor.psm1 to build a CodeCoverage package on daily builds and publish it as a zip. * Addressed code review comments Changed from Add-Member to use pscustomobject type accelator. Removed [gc]::collect. * Added explicit garbage collection * Addressed code review comments - Make sure that the build Start-PSPackage gets is not a code coverage build - Add debugType = full for FullCLR - Remove configurations from PackageManagement files as it is not needed. - Build CodeCoverage build first in AppVeyor. * Resolve merge conflict * Fix indentation * Fix newline at end of file * Added command discovery for locating OpenCover.console.exe
2016-11-11 20:12:07 +01:00
"CodeCoverage" {
if(-not $IsWindows) {
$Configuration = "Linux"
Write-Warning ($ConfigWarningMsg -f $switch.Current, $LinuxInfo.PRETTY_NAME, $Configuration)
}
}
Default {
if ($IsLinux -or $IsOSX) {
$Configuration = "Linux"
Write-Warning ($ConfigWarningMsg -f $switch.Current, $LinuxInfo.PRETTY_NAME, $Configuration)
}
}
}
}
Write-Verbose "Using configuration '$Configuration'"
$PowerShellDir = if ($FullCLR) {
"powershell-win-full"
} elseif ($Configuration -eq 'Linux') {
"powershell-unix"
} else {
"powershell-win-core"
}
$Top = [IO.Path]::Combine($PSScriptRoot, "src", $PowerShellDir)
Write-Verbose "Top project directory is $Top"
if (-not $Framework) {
$Framework = if ($FullCLR) {
"net451"
} else {
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
"netcoreapp2.0"
}
Write-Verbose "Using framework '$Framework'"
}
if (-not $Runtime) {
$Runtime = dotnet --info | % {
if ($_ -match "RID") {
$_ -split "\s+" | Select-Object -Last 1
}
}
if (-not $Runtime) {
Throw "Could not determine Runtime Identifier, please update dotnet"
} else {
Write-Verbose "Using runtime '$Runtime'"
}
2016-04-02 07:01:37 +02:00
}
$Executable = if ($IsLinux -or $IsOSX) {
"powershell"
} elseif ($IsWindows) {
"powershell.exe"
}
# Build the Output path
if (!$Output) {
$Output = [IO.Path]::Combine($Top, "bin", $Configuration, $Framework, $Runtime, "publish", $Executable)
}
if ($SMAOnly)
{
$Top = [IO.Path]::Combine($PSScriptRoot, "src", "System.Management.Automation")
}
return @{ Top = $Top;
Configuration = $Configuration;
Framework = $Framework;
Runtime = $Runtime;
Output = $Output;
CrossGen = $CrossGen }
}
function Get-PSOutput {
[CmdletBinding()]param(
[hashtable]$Options
)
if ($Options) {
return $Options.Output
} elseif ($script:Options) {
return $script:Options.Output
} else {
return (New-PSOptions).Output
}
}
2016-04-02 07:01:05 +02:00
function Get-PesterTag {
param ( [Parameter(Position=0)][string]$testbase = "$PSScriptRoot/test/powershell" )
$alltags = @{}
$warnings = @()
get-childitem -Recurse $testbase -File |?{$_.name -match "tests.ps1"}| %{
$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[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 | % {
if (@('REQUIREADMINONWINDOWS', '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()
Find-Dotnet
$tools = @(
@{Path="${PSScriptRoot}/test/tools/TestExe";Output="testexe"}
)
2017-03-23 21:04:52 +01:00
if ($Options -eq $null)
{
$Options = New-PSOptions
}
# Publish tools so it can be run by tests
foreach ($tool in $tools)
{
Push-Location $tool.Path
try {
2017-03-23 21:04:52 +01:00
dotnet publish --output bin --configuration $Options.Configuration --framework $Options.Framework --runtime $Options.Runtime
$toolPath = Join-Path -Path $tool.Path -ChildPath "bin"
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
# add 'x' permission when building the standalone application
# this is temporary workaround to a bug in dotnet.exe, tracking by dotnet/cli issue #6286
if ($Options.Configuration -eq "Linux") {
$executable = Join-Path -Path $toolPath -ChildPath "$($tool.Output)"
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
chmod u+x $executable
}
if ( $env:PATH -notcontains $toolPath ) {
$env:PATH = $toolPath+$TestModulePathSeparator+$($env:PATH)
}
} finally {
Pop-Location
}
}
}
function Start-PSPester {
[CmdletBinding()]
param(
[string]$OutputFormat = "NUnitXml",
[string]$OutputFile = "pester-tests.xml",
[string[]]$ExcludeTag = 'Slow',
[string[]]$Tag = @("CI","Feature"),
[string[]]$Path = @("$PSScriptRoot/test/common","$PSScriptRoot/test/powershell"),
[switch]$ThrowOnFailure,
[switch]$FullCLR,
[string]$binDir = (Split-Path (New-PSOptions -FullCLR:$FullCLR).Output),
[string]$powershell = (Join-Path $binDir 'powershell'),
[string]$Pester = ([IO.Path]::Combine($binDir, "Modules", "Pester")),
[switch]$Unelevate,
[switch]$Quiet,
[switch]$PassThru
)
2017-03-23 21:04:52 +01:00
if ($FullCLR) {
## Stop building 'FullCLR', but keep the parameters and related scripts for now.
## Once we confirm that portable modules is supported with .NET Core 2.0, we will clean up all FullCLR related scripts.
throw "Building against FullCLR is not supported"
}
# we need to do few checks and if user didn't provide $ExcludeTag explicitly, we should alternate the default
if ($Unelevate)
{
if (-not $IsWindows)
{
throw '-Unelevate is currently not supported on non-Windows platforms'
}
if (-not $IsAdmin)
{
throw '-Unelevate cannot be applied because the current user is not Administrator'
}
if (-not $PSBoundParameters.ContainsKey('ExcludeTag'))
{
$ExcludeTag += 'RequireAdminOnWindows'
}
}
elseif ($IsWindows -and (-not $IsAdmin))
{
if (-not $PSBoundParameters.ContainsKey('ExcludeTag'))
{
$ExcludeTag += 'RequireAdminOnWindows'
}
}
Write-Verbose "Running pester tests at '$path' with tag '$($Tag -join ''', ''')' and ExcludeTag '$($ExcludeTag -join ''', ''')'" -Verbose
Publish-PSTestTools
# All concatenated commands/arguments are suffixed with the delimiter (space)
$Command = ""
# Autoload (in subprocess) temporary modules used in our tests
$Command += '$env:PSModulePath = '+"'$TestModulePath$TestModulePathSeparator'" + '+$($env:PSModulePath);'
# Windows needs the execution policy adjusted
if ($IsWindows) {
$Command += "Set-ExecutionPolicy -Scope Process Unrestricted; "
}
$startParams = @{binDir=$binDir}
if(!$FullCLR)
{
$Command += "Import-Module '$Pester'; "
}
if ($Unelevate)
{
$outputBufferFilePath = [System.IO.Path]::GetTempFileName()
}
2017-01-16 22:31:14 +01:00
$Command += "Invoke-Pester "
$Command += "-OutputFormat ${OutputFormat} -OutputFile ${OutputFile} "
if ($ExcludeTag -and ($ExcludeTag -ne "")) {
$Command += "-ExcludeTag @('" + (${ExcludeTag} -join "','") + "') "
}
if ($Tag) {
$Command += "-Tag @('" + (${Tag} -join "','") + "') "
}
# sometimes we need to eliminate Pester output, especially when we're
# doing a daily build as the log file is too large
if ( $Quiet ) {
$Command += "-Quiet "
}
if ( $PassThru ) {
$Command += "-PassThru "
}
$Command += "'" + ($Path -join "','") + "'"
if ($Unelevate)
{
$Command += " *> $outputBufferFilePath; '__UNELEVATED_TESTS_THE_END__' >> $outputBufferFilePath"
}
Write-Verbose $Command
# To ensure proper testing, the module path must not be inherited by the spawned process
if($FullCLR)
{
Start-DevPowerShell -binDir $binDir -FullCLR -NoNewWindow -ArgumentList '-noprofile', '-noninteractive' -Command $command
}
else {
try {
$originalModulePath = $env:PSModulePath
if ($Unelevate)
{
Start-UnelevatedProcess -process $powershell -arguments @('-noprofile', '-c', $Command)
$currentLines = 0
while ($true)
{
$lines = Get-Content $outputBufferFilePath | Select-Object -Skip $currentLines
$lines | Write-Host
if ($lines | ? { $_ -eq '__UNELEVATED_TESTS_THE_END__'})
{
break
}
$count = ($lines | measure-object).Count
if ($count -eq 0)
{
sleep 1
}
else
{
$currentLines += $count
}
}
}
else
{
& $powershell -noprofile -c $Command
}
} finally {
$env:PSModulePath = $originalModulePath
if ($Unelevate)
{
Remove-Item $outputBufferFilePath
}
2017-01-16 22:31:14 +01:00
}
}
if($ThrowOnFailure)
{
Test-PSPesterResults -TestResultsFile $OutputFile
}
}
function script:Start-UnelevatedProcess
{
param(
[string]$process,
[string[]]$arguments
)
if (-not $IsWindows)
{
throw "Start-UnelevatedProcess is currently not supported on non-Windows platforms"
}
runas.exe /trustlevel:0x20000 "$process $arguments"
}
function Show-PSPesterError
{
param ( [Xml.XmlElement]$testFailure )
logerror ("Description: " + $testFailure.description)
logerror ("Name: " + $testFailure.name)
logerror "message:"
logerror $testFailure.failure.message
logerror "stack-trace:"
logerror $testFailure.failure."stack-trace"
}
#
# Read the test result file and
2017-01-16 22:31:14 +01:00
# Throw if a test failed
function Test-PSPesterResults
{
param(
[string]$TestResultsFile = "pester-tests.xml",
[string]$TestArea = 'test/powershell'
)
if(!(Test-Path $TestResultsFile))
{
throw "Test result file '$testResultsFile' not found for $TestArea."
2017-01-16 22:31:14 +01:00
}
$x = [xml](Get-Content -raw $testResultsFile)
if ([int]$x.'test-results'.failures -gt 0)
{
logerror "TEST FAILURES"
Jameswtruher/travisdailybuild (#2958) * Stifle progress output in build.psm1 for some operations Modify test failure presentation to use platform available XML methods * Add timeout support for returning runtime parsing errors Some of the language/parser tests have been hanging in a non-reproducable manner which causes the CI system to invalidate the entire run. This change adds support for timeout which will fail a test if it runs to long, rather than invalidate the entire run. current behavior is still supported, and is not done in a new session: PS> get-runtimeerror -src '1/' At line:1 char:3 + 1/ + ~ You must provide a value expression following the '/' operator. + CategoryInfo : ParserError: (:) [], ParentContainsErrorRecordException + FullyQualifiedErrorId : ExpectedValueExpression Adding a timeout will do the operation in a async powershell session PS> get-runtimeerror -src '1/' -timeout 5 You must provide a value expression following the '/' operator. + CategoryInfo : ParserError: (:) [], ParentContainsErrorRecordException + FullyQualifiedErrorId : ExpectedValueExpression If the operation takes longer than the supplied timeout, a timeout error will be returned PS> get-runtimeerror -src 'start-sleep 6' -timeout 2 get-runtimeerror : Operation Timed Out ('start-sleep 6') At line:1 char:1 + get-runtimeerror -src 'start-sleep 6' -timeout 2 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : NotSpecified: (:) [Write-Error], WriteErrorException + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-RuntimeError * Modify native linux command tests to skip on Windows and pending on Mac * remove verbose and progress output from help tests * Be sure that Feature Counter tests only run on Windows Also, only call add-type in CounterTestHelperFunctions.ps1 if we're going to actually run the tests * do not run any get-computerinfo tests on non-windows systems * suppress progress output from PowerShell Get tests * remove -quiet from API and CRON Builds Travis watches output from the build to ensure that it hasn't hung we need to find a balance between too much output and not enough output. A run which has too much output is killed because it looks like an error loop A run which has too little output is killed because it looks like a hang * Remove commented line in Import-Counter.Tests.ps1 Remove extraneous extra line in PowerShellGet.Tests.ps1 * Change `-as "type"` to `-as [type]` in build.psm1 Alter timeout to 10 seconds to be improve chances of not timing out for runtime parser checks improve logic for counter tests to also skip for IoT * use the existing function of SkipCounterTests rather than duplicate the logic in import-counter.tests.ps1
2017-01-10 23:42:27 +01:00
# switch between methods, SelectNode is not available on dotnet core
if ( "System.Xml.XmlDocumentXPathExtensions" -as [Type] ) {
$failures = [System.Xml.XmlDocumentXPathExtensions]::SelectNodes($x."test-results",'.//test-case[@result = "Failure"]')
}
else {
$failures = $x.SelectNodes('.//test-case[@result = "Failure"]')
}
foreach ( $testfail in $failures )
{
Show-PSPesterError $testfail
}
throw "$($x.'test-results'.failures) tests in $TestArea failed"
}
}
function Start-PSxUnit {
2016-04-02 07:01:05 +02:00
[CmdletBinding()]param()
log "xUnit tests are currently disabled pending fixes due to API and AssemblyLoadContext changes - @andschwa"
return
if ($IsWindows) {
throw "xUnit tests are only currently supported on Linux / OS X"
}
2016-04-02 07:01:37 +02:00
if ($IsOSX) {
log "Not yet supported on OS X, pretending they passed..."
return
}
# Add .NET CLI tools to PATH
Find-Dotnet
$Arguments = "--configuration", "Linux", "-parallel", "none"
2016-06-01 01:06:19 +02:00
if ($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent) {
$Arguments += "-verbose"
2016-06-01 01:06:19 +02:00
}
2016-04-02 07:01:37 +02:00
$Content = Split-Path -Parent (Get-PSOutput)
if (-not (Test-Path $Content)) {
throw "PowerShell must be built before running tests!"
}
try {
Push-Location $PSScriptRoot/test/csharp
# Path manipulation to obtain test project output directory
$Output = Join-Path $pwd ((Split-Path -Parent (Get-PSOutput)) -replace (New-PSOptions).Top)
Write-Verbose "Output is $Output"
Copy-Item -ErrorAction SilentlyContinue -Recurse -Path $Content/* -Include Modules,libpsl-native* -Destination $Output
Start-NativeExecution { dotnet test $Arguments }
if ($LASTEXITCODE -ne 0) {
throw "$LASTEXITCODE xUnit tests failed"
}
} finally {
Pop-Location
}
}
function Install-Dotnet {
[CmdletBinding()]
param(
[string]$Channel = $dotnetCLIChannel,
[string]$Version = $dotnetCLIRequiredVersion,
[switch]$NoSudo
)
# This allows sudo install to be optional; needed when running in containers / as root
# Note that when it is null, Invoke-Expression (but not &) must be used to interpolate properly
$sudo = if (!$NoSudo) { "sudo" }
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
$obtainUrl = "https://raw.githubusercontent.com/dotnet/cli/master/scripts/obtain"
# Install for Linux and OS X
if ($IsLinux -or $IsOSX) {
# Uninstall all previous dotnet packages
$uninstallScript = if ($IsUbuntu) {
"dotnet-uninstall-debian-packages.sh"
} elseif ($IsOSX) {
"dotnet-uninstall-pkgs.sh"
}
if ($uninstallScript) {
Start-NativeExecution {
curl -sO $obtainUrl/uninstall/$uninstallScript
Invoke-Expression "$sudo bash ./$uninstallScript"
}
} else {
Write-Warning "This script only removes prior versions of dotnet for Ubuntu 14.04 and OS X"
}
# Install new dotnet 1.1.0 preview packages
$installScript = "dotnet-install.sh"
Start-NativeExecution {
curl -sO $obtainUrl/$installScript
bash ./$installScript -c $Channel -v $Version
}
} elseif ($IsWindows) {
Remove-Item -ErrorAction SilentlyContinue -Recurse -Force ~\AppData\Local\Microsoft\dotnet
$installScript = "dotnet-install.ps1"
Invoke-WebRequest -Uri $obtainUrl/$installScript -OutFile $installScript
if (-not $IsCoreCLR) {
& ./$installScript -Channel $Channel -Version $Version
} else {
# dotnet-install.ps1 uses APIs that are not supported in .NET Core, so we run it with Windows PowerShell
$fullPSPath = Join-Path -Path $env:windir -ChildPath "System32\WindowsPowerShell\v1.0\powershell.exe"
$fullDotnetInstallPath = Join-Path -Path $pwd.Path -ChildPath $installScript
Start-NativeExecution { & $fullPSPath -NoLogo -NoProfile -File $fullDotnetInstallPath -Channel $Channel -Version $Version }
}
}
}
function Get-RedHatPackageManager {
if ($IsCentOS) {
"yum install -y -q"
} elseif ($IsFedora) {
"dnf install -y -q"
} elseif ($IsOpenSUSE) {
"zypper --non-interactive install"
} else {
throw "Error determining package manager for this distribution."
}
}
function Start-PSBootstrap {
[CmdletBinding(
SupportsShouldProcess=$true,
ConfirmImpact="High")]
param(
[string]$Channel = $dotnetCLIChannel,
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
# we currently pin dotnet-cli version, and will
# update it when more stable version comes out.
[string]$Version = $dotnetCLIRequiredVersion,
[switch]$Package,
[switch]$NoSudo,
[switch]$Force
)
log "Installing PowerShell build dependencies"
Push-Location $PSScriptRoot/tools
# This allows sudo install to be optional; needed when running in containers / as root
# Note that when it is null, Invoke-Expression (but not &) must be used to interpolate properly
$sudo = if (!$NoSudo) { "sudo" }
try {
# Update googletest submodule for linux native cmake
if ($IsLinux -or $IsOSX) {
try {
Push-Location $PSScriptRoot
$Submodule = "$PSScriptRoot/src/libpsl-native/test/googletest"
Remove-Item -Path $Submodule -Recurse -Force -ErrorAction SilentlyContinue
2017-07-12 07:07:31 +02:00
git submodule --quiet update --init -- $submodule
} finally {
Pop-Location
}
}
# Install ours and .NET's dependencies
2016-07-05 19:36:38 +02:00
$Deps = @()
if ($IsUbuntu) {
2016-07-05 19:36:38 +02:00
# Build tools
$Deps += "curl", "g++", "cmake", "make"
2016-08-11 22:38:35 +02:00
2016-07-05 19:36:38 +02:00
# .NET Core required runtime libraries
2016-08-11 22:38:35 +02:00
$Deps += "libunwind8"
if ($IsUbuntu14) { $Deps += "libicu52" }
elseif ($IsUbuntu16) { $Deps += "libicu55" }
# Packaging tools
if ($Package) { $Deps += "ruby-dev", "groff" }
2016-08-11 22:38:35 +02:00
2016-07-05 19:36:38 +02:00
# Install dependencies
Start-NativeExecution {
2017-07-12 07:07:31 +02:00
Invoke-Expression "$sudo apt-get update -qq"
Invoke-Expression "$sudo apt-get install -y -qq $Deps"
}
} elseif ($IsRedHatFamily) {
2016-07-05 19:36:38 +02:00
# Build tools
$Deps += "which", "curl", "gcc-c++", "cmake", "make"
2016-08-11 22:38:35 +02:00
2016-07-05 19:36:38 +02:00
# .NET Core required runtime libraries
$Deps += "libicu", "libunwind"
2016-08-11 22:38:35 +02:00
# Packaging tools
if ($Package) { $Deps += "ruby-devel", "rpm-build", "groff" }
2016-08-11 22:38:35 +02:00
$PackageManager = Get-RedHatPackageManager
$baseCommand = "$sudo $PackageManager"
# On OpenSUSE 13.2 container, sudo does not exist, so don't use it if not needed
if($NoSudo)
{
$baseCommand = $PackageManager
}
2016-07-05 19:36:38 +02:00
# Install dependencies
Start-NativeExecution {
Invoke-Expression "$baseCommand $Deps"
}
} elseif ($IsOSX) {
precheck 'brew' "Bootstrap dependency 'brew' not found, must install Homebrew! See http://brew.sh/"
2016-08-11 22:38:35 +02:00
2016-07-05 19:36:38 +02:00
# Build tools
$Deps += "cmake"
2016-08-11 22:38:35 +02:00
2016-07-05 19:36:38 +02:00
# .NET Core required runtime libraries
$Deps += "openssl"
2016-08-11 22:38:35 +02:00
2016-07-05 19:36:38 +02:00
# Install dependencies
# ignore exitcode, because they may be already installed
Start-NativeExecution { brew install $Deps } -IgnoreExitcode
# Install patched version of curl
Start-NativeExecution { brew install curl --with-openssl } -IgnoreExitcode
}
# Install [fpm](https://github.com/jordansissel/fpm) and [ronn](https://github.com/rtomayko/ronn)
if ($Package) {
try {
# We cannot guess if the user wants to run gem install as root
Start-NativeExecution { gem install fpm ronn }
} catch {
Write-Warning "Installation of fpm and ronn gems failed! Must resolve manually."
}
}
$dotNetExists = precheck 'dotnet' $null
$dotNetVersion = [string]::Empty
if($dotNetExists) {
$dotNetVersion = (dotnet --version)
}
if(!$dotNetExists -or $dotNetVersion -ne $dotnetCLIRequiredVersion -or $Force.IsPresent) {
if($Force.IsPresent) {
log "Installing dotnet due to -Force."
}
elseif(!$dotNetExistis) {
log "dotnet not present. Installing dotnet."
}
else {
log "dotnet out of date ($dotNetVersion). Updating dotnet."
}
$DotnetArguments = @{ Channel=$Channel; Version=$Version; NoSudo=$NoSudo }
Install-Dotnet @DotnetArguments
}
else
{
log "dotnet is already installed. Skipping installation."
}
# Install for Windows
if ($IsWindows) {
$machinePath = [Environment]::GetEnvironmentVariable('Path', 'MACHINE')
2016-07-22 00:47:28 +02:00
$newMachineEnvironmentPath = $machinePath
$cmakePresent = precheck 'cmake' $null
$sdkPresent = Test-Win10SDK
2016-07-22 00:47:28 +02:00
# Install chocolatey
$chocolateyPath = "$env:AllUsersProfile\chocolatey\bin"
if(precheck 'choco' $null) {
log "Chocolatey is already installed. Skipping installation."
}
elseif(($cmakePresent -eq $false) -or ($sdkPresent -eq $false)) {
log "Chocolatey not present. Installing chocolatey."
if ($Force -or $PSCmdlet.ShouldProcess("Install chocolatey via https://chocolatey.org/install.ps1")) {
Invoke-Expression ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))
if (-not ($machinePath.ToLower().Contains($chocolateyPath.ToLower()))) {
log "Adding $chocolateyPath to Path environment variable"
$env:Path += ";$chocolateyPath"
$newMachineEnvironmentPath += ";$chocolateyPath"
} else {
log "$chocolateyPath already present in Path environment variable"
}
} else {
Write-Error "Chocolatey is required to install missing dependencies. Please install it from https://chocolatey.org/ manually. Alternatively, install cmake and Windows 10 SDK."
return $null
}
} else {
log "Skipping installation of chocolatey, cause both cmake and Win 10 SDK are present."
}
2016-07-22 00:47:28 +02:00
# Install cmake
2016-08-25 17:47:52 +02:00
$cmakePath = "${env:ProgramFiles}\CMake\bin"
if($cmakePresent) {
2016-07-22 00:47:28 +02:00
log "Cmake is already installed. Skipping installation."
} else {
2016-07-22 00:47:28 +02:00
log "Cmake not present. Installing cmake."
Start-NativeExecution { choco install cmake -y --version 3.6.0 }
if (-not ($machinePath.ToLower().Contains($cmakePath.ToLower()))) {
2016-07-22 00:47:28 +02:00
log "Adding $cmakePath to Path environment variable"
$env:Path += ";$cmakePath"
$newMachineEnvironmentPath = "$cmakePath;$newMachineEnvironmentPath"
} else {
2016-07-22 00:47:28 +02:00
log "$cmakePath already present in Path environment variable"
}
}
# Install Windows 10 SDK
2016-07-22 01:10:57 +02:00
$packageName = "windows-sdk-10.0"
if (-not $sdkPresent) {
2016-07-22 01:10:57 +02:00
log "Windows 10 SDK not present. Installing $packageName."
Start-NativeExecution { choco install windows-sdk-10.0 -y }
} else {
2016-07-22 01:10:57 +02:00
log "Windows 10 SDK present. Skipping installation."
}
# Update path machine environment variable
if ($newMachineEnvironmentPath -ne $machinePath) {
log "Updating Path machine environment variable"
if ($Force -or $PSCmdlet.ShouldProcess("Update Path machine environment variable to $newMachineEnvironmentPath")) {
[Environment]::SetEnvironmentVariable('Path', $newMachineEnvironmentPath, 'MACHINE')
}
2016-07-22 00:47:28 +02:00
}
}
} finally {
Pop-Location
}
}
2016-04-01 23:41:13 +02:00
function Start-PSPackage {
[CmdletBinding(DefaultParameterSetName='Version')]
param(
# PowerShell packages use Semantic Versioning http://semver.org/
[Parameter(ParameterSetName = "Version")]
[string]$Version,
[Parameter(ParameterSetName = "ReleaseTag")]
[ValidatePattern("^v\d+\.\d+\.\d+(-\w+\.\d+)?$")]
[ValidateNotNullOrEmpty()]
[string]$ReleaseTag,
# Package name
2016-08-11 01:21:25 +02:00
[ValidatePattern("^powershell")]
[string]$Name = "powershell",
# Ubuntu, CentOS, Fedora, OS X, and Windows packages are supported
2017-02-14 01:45:05 +01:00
[ValidateSet("deb", "osxpkg", "rpm", "msi", "appx", "zip", "AppImage")]
[string[]]$Type,
2017-01-16 22:31:14 +01:00
# Generate windows downlevel package
2016-11-15 19:14:31 +01:00
[ValidateSet("win81-x64", "win7-x86", "win7-x64")]
[ValidateScript({$IsWindows})]
[string]$WindowsDownLevel
)
2016-08-10 23:10:43 +02:00
# Runtime and Configuration settings required by the package
($Runtime, $Configuration) = if ($WindowsDownLevel) {
$WindowsDownLevel, "Release"
} else {
New-PSOptions -Configuration "Release" -WarningAction SilentlyContinue | ForEach-Object { $_.Runtime, $_.Configuration }
}
Write-Verbose "Packaging RID: '$Runtime'; Packaging Configuration: '$Configuration'" -Verbose
# Make sure the most recent build satisfies the package requirement
2016-11-20 21:59:50 +01:00
if (-not $Script:Options -or ## Start-PSBuild hasn't been executed yet
-not $Script:Options.CrossGen -or ## Last build didn't specify -CrossGen
$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'
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
$Script:Options.Framework -ne "netcoreapp2.0") ## Last build wasn't for CoreCLR
{
# It's possible that the most recent build doesn't satisfy the package requirement but
# an earlier build does. e.g., run the following in order on win10-x64:
# Start-PSBuild -Clean -CrossGen -Runtime win10-x64 -Configuration Release
# Start-PSBuild -FullCLR
# Start-PSPackage -Type msi
# 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.
throw "Please ensure you have run 'Start-PSBuild -Clean -CrossGen -Runtime $Runtime -Configuration $Configuration'!"
}
# If ReleaseTag is specified, use the given tag to calculate Vesrion
if ($PSCmdlet.ParameterSetName -eq "ReleaseTag") {
$Version = $ReleaseTag -Replace '^v'
}
# Use Git tag if not given a version
if (-not $Version) {
$Version = (git --git-dir="$PSScriptRoot/.git" describe) -Replace '^v'
}
$Source = Split-Path -Path $Script:Options.Output -Parent
Write-Verbose "Packaging Source: '$Source'" -Verbose
# Decide package output type
if (-not $Type) {
$Type = if ($IsLinux) {
if ($LinuxInfo.ID -match "ubuntu") {
"deb"
} elseif ($IsRedHatFamily) {
"rpm"
} else {
throw "Building packages for $($LinuxInfo.PRETTY_NAME) is unsupported!"
}
} elseif ($IsOSX) {
"osxpkg"
} elseif ($IsWindows) {
"msi", "appx"
}
Write-Warning "-Type was not specified, continuing with $Type!"
}
# Build the name suffix for win-plat packages
if ($IsWindows) {
# Add the server name to the $RunTime. $runtime produced by dotnet is same for client or server
switch ($Runtime) {
'win81-x64' {$NameSuffix = 'win81-win2012r2-x64'}
'win10-x64' {$NameSuffix = 'win10-win2016-x64'}
'win7-x64' {$NameSuffix = 'win7-win2008r2-x64'}
Default {$NameSuffix = $Runtime}
}
}
switch ($Type) {
"zip" {
$Arguments = @{
PackageNameSuffix = $NameSuffix
PackageSourcePath = $Source
PackageVersion = $Version
}
New-ZipPackage @Arguments
}
"msi" {
2016-11-16 19:32:21 +01:00
$TargetArchitecture = "x64"
if ($Runtime -match "-x86")
{
$TargetArchitecture = "x86"
}
$Arguments = @{
ProductNameSuffix = $NameSuffix
ProductSourcePath = $Source
ProductVersion = $Version
AssetsPath = "$PSScriptRoot\assets"
LicenseFilePath = "$PSScriptRoot\assets\license.rtf"
# Product Guid needs to be unique for every PowerShell version to allow SxS install
2016-11-16 19:32:21 +01:00
ProductGuid = [Guid]::NewGuid();
ProductTargetArchitecture = $TargetArchitecture;
}
New-MSIPackage @Arguments
}
"appx" {
$Arguments = @{
PackageNameSuffix = $NameSuffix
PackageSourcePath = $Source
PackageVersion = $Version
AssetsPath = "$PSScriptRoot\assets"
}
New-AppxPackage @Arguments
}
2017-02-14 01:45:05 +01:00
"AppImage" {
if ($IsUbuntu14) {
Start-NativeExecution { bash -iex "$PSScriptRoot/tools/appimage.sh" }
$appImage = Get-Item PowerShell-*.AppImage
if ($appImage.Count -gt 1) {
throw "Found more than one AppImage package, remove all *.AppImage files and try to create the package again"
}
Rename-Item $appImage.Name $appImage.Name.Replace("-","-$Version-")
2017-02-14 01:45:05 +01:00
} else {
Write-Warning "Ignoring AppImage type for non Ubuntu Trusty platform"
}
}
default {
$Arguments = @{
Type = $_
PackageSourcePath = $Source
Name = $Name
Version = $Version
}
New-UnixPackage @Arguments
}
}
}
function New-UnixPackage {
[CmdletBinding()]
param(
[Parameter(Mandatory)]
[ValidateSet("deb", "osxpkg", "rpm")]
[string]$Type,
[Parameter(Mandatory)]
[string]$PackageSourcePath,
2016-08-11 01:21:25 +02:00
# Must start with 'powershell' but may have any suffix
[Parameter(Mandatory)]
2016-08-11 01:21:25 +02:00
[ValidatePattern("^powershell")]
[string]$Name,
[Parameter(Mandatory)]
[string]$Version,
# Package iteration version (rarely changed)
# This is a string because strings are appended to it
[string]$Iteration = "1"
)
2016-08-11 22:38:35 +02:00
# Validate platform
$ErrorMessage = "Must be on {0} to build '$Type' packages!"
switch ($Type) {
"deb" {
$WarningMessage = "Building for Ubuntu {0}.04!"
if (!$IsUbuntu) {
throw ($ErrorMessage -f "Ubuntu")
} elseif ($IsUbuntu14) {
Write-Warning ($WarningMessage -f "14")
} elseif ($IsUbuntu16) {
Write-Warning ($WarningMessage -f "16")
}
}
"rpm" {
if (!$IsRedHatFamily) {
throw ($ErrorMessage -f "Redhat Family")
2016-08-11 22:38:35 +02:00
}
}
"osxpkg" {
if (!$IsOSX) {
throw ($ErrorMessage -f "OS X")
}
}
}
foreach ($Dependency in "fpm", "ronn") {
if (!(precheck $Dependency "Package dependency '$Dependency' not found. Run Start-PSBootstrap -Package")) {
# These tools are not added to the path automatically on OpenSUSE 13.2
# try adding them to the path and re-tesing first
[string] $gemsPath = $null
[string] $depenencyPath = $null
$gemsPath = Get-ChildItem -Path /usr/lib64/ruby/gems | Sort-Object -Property LastWriteTime -Descending | Select-Object -First 1 -ExpandProperty FullName
if($gemsPath) {
$depenencyPath = Get-ChildItem -Path (Join-Path -Path $gemsPath -ChildPath "gems" -AdditionalChildPath $Dependency) -Recurse | Sort-Object -Property LastWriteTime -Descending | Select-Object -First 1 -ExpandProperty DirectoryName
$originalPath = $env:PATH
$env:PATH = $ENV:PATH +":" + $depenencyPath
if((precheck $Dependency "Package dependency '$Dependency' not found. Run Start-PSBootstrap -Package")) {
continue
}
else {
$env:PATH = $originalPath
}
}
throw "Dependency precheck failed!"
}
}
$Description = @"
PowerShell is an automation and configuration management platform.
It consists of a cross-platform command-line shell and associated scripting language.
"@
2016-08-11 01:21:25 +02:00
# Suffix is used for side-by-side package installation
$Suffix = $Name -replace "^powershell"
if (!$Suffix) {
Write-Warning "Suffix not given, building primary PowerShell package!"
$Suffix = $Version
}
# Setup staging directory so we don't change the original source directory
$Staging = "$PSScriptRoot/staging"
Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $Staging
Copy-Item -Recurse $PackageSourcePath $Staging
2016-08-11 01:21:25 +02:00
# 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"
}
}
# Follow the Filesystem Hierarchy Standard for Linux and OS X
$Destination = if ($IsLinux) {
2016-08-11 01:21:25 +02:00
"/opt/microsoft/powershell/$Suffix"
} elseif ($IsOSX) {
2016-08-11 01:21:25 +02:00
"/usr/local/microsoft/powershell/$Suffix"
}
# Destination for symlink to powershell executable
$Link = if ($IsLinux) {
"/usr/bin"
} elseif ($IsOSX) {
"/usr/local/bin"
}
2016-08-11 01:21:25 +02:00
New-Item -Force -ItemType SymbolicLink -Path "/tmp/$Name" -Target "$Destination/$Name" >$null
if ($IsRedHatFamily) {
# 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 OSX builds for itself
# against the correct versions.
New-Item -Force -ItemType SymbolicLink -Target "/lib64/libssl.so.10" -Path "$Staging/libssl.so.1.0.0" >$null
New-Item -Force -ItemType SymbolicLink -Target "/lib64/libcrypto.so.10" -Path "$Staging/libcrypto.so.1.0.0" >$null
$AfterInstallScript = [io.path]::GetTempFileName()
$AfterRemoveScript = [io.path]::GetTempFileName()
@'
#!/bin/sh
if [ ! -f /etc/shells ] ; then
echo "{0}" > /etc/shells
else
grep -q "^{0}$" /etc/shells || echo "{0}" >> /etc/shells
fi
'@ -f "$Link/$Name" | Out-File -FilePath $AfterInstallScript -Encoding ascii
@'
if [ "$1" = 0 ] ; then
if [ -f /etc/shells ] ; then
TmpFile=`/bin/mktemp /tmp/.powershellmXXXXXX`
grep -v '^{0}$' /etc/shells > $TmpFile
cp -f $TmpFile /etc/shells
rm -f $TmpFile
fi
fi
'@ -f "$Link/$Name" | Out-File -FilePath $AfterRemoveScript -Encoding ascii
}
elseif ($IsUbuntu) {
$AfterInstallScript = [io.path]::GetTempFileName()
$AfterRemoveScript = [io.path]::GetTempFileName()
@'
#!/bin/sh
set -e
case "$1" in
(configure)
add-shell "{0}"
;;
(abort-upgrade|abort-remove|abort-deconfigure)
exit 0
;;
(*)
echo "postinst called with unknown argument '$1'" >&2
exit 0
;;
esac
'@ -f "$Link/$Name" | Out-File -FilePath $AfterInstallScript -Encoding ascii
@'
#!/bin/sh
set -e
case "$1" in
(remove)
remove-shell "{0}"
;;
esac
'@ -f "$Link/$Name" | Out-File -FilePath $AfterRemoveScript -Encoding ascii
}
# there is a weird bug in fpm
# if the target of the powershell symlink exists, `fpm` aborts
# with a `utime` error on OS X.
# so we move it to make symlink broken
2016-08-11 01:21:25 +02:00
$symlink_dest = "$Destination/$Name"
$hack_dest = "./_fpm_symlink_hack_powershell"
if ($IsOSX) {
if (Test-Path $symlink_dest) {
Write-Warning "Move $symlink_dest to $hack_dest (fpm utime bug)"
Move-Item $symlink_dest $hack_dest
}
}
# run ronn to convert man page to roff
2016-08-11 01:21:25 +02:00
$RonnFile = Join-Path $PSScriptRoot "/assets/powershell.1.ronn"
$RoffFile = $RonnFile -replace "\.ronn$"
2016-08-10 23:10:43 +02:00
# Run ronn on assets file
2016-08-11 01:21:25 +02:00
# Run does not play well with files named powershell6.0.1, so we generate and then rename
Start-NativeExecution { ronn --roff $RonnFile }
2016-08-10 23:10:43 +02:00
2016-08-11 01:21:25 +02:00
# Setup for side-by-side man pages (noop if primary package)
$FixedRoffFile = $RoffFile -replace "powershell.1$", "$Name.1"
if ($Name -ne "powershell") {
Move-Item $RoffFile $FixedRoffFile
}
# gzip in assets directory
2016-08-11 01:21:25 +02:00
$GzipFile = "$FixedRoffFile.gz"
Start-NativeExecution { gzip -f $FixedRoffFile }
$ManFile = Join-Path "/usr/local/share/man/man1" (Split-Path -Leaf $GzipFile)
2016-08-10 23:10:43 +02:00
# Change permissions for packaging
Start-NativeExecution {
find $Staging -type d | xargs chmod 755
find $Staging -type f | xargs chmod 644
chmod 644 $GzipFile
chmod 755 "$Staging/$Name" # only the executable should be executable
}
# Setup package dependencies
# These should match those in the Dockerfiles, but exclude tools like Git, which, and curl
$Dependencies = @()
if ($IsUbuntu) {
$Dependencies = @(
"libc6",
"libcurl3",
"libgcc1",
"libssl1.0.0",
"libstdc++6",
"libtinfo5",
"libunwind8",
"libuuid1",
"zlib1g"
)
# Please note the different libicu package dependency!
if ($IsUbuntu14) {
$Dependencies += "libicu52"
} elseif ($IsUbuntu16) {
$Dependencies += "libicu55"
2016-08-11 22:38:35 +02:00
}
} elseif ($IsRedHatFamily) {
$Dependencies = @(
"glibc",
"libicu",
"openssl",
"libunwind",
"uuid",
"zlib"
)
if($IsFedora -or $IsCentOS)
{
$Dependencies += "libcurl"
$Dependencies += "libgcc"
$Dependencies += "libstdc++"
$Dependencies += "ncurses-base"
}
if($IsOpenSUSE)
{
$Dependencies += "libgcc_s1"
$Dependencies += "libstdc++6"
}
}
# iteration is "debian_revision"
# usage of this to differentiate distributions is allowed by non-standard
if ($IsUbuntu14) {
$Iteration += "ubuntu1.14.04.1"
} elseif ($IsUbuntu16) {
$Iteration += "ubuntu1.16.04.1"
}
# We currently only support:
# CentOS 7
# Fedora 24+
# OpenSUSE 42.1 (13.2 might build but is EOL)
# Also SEE: https://fedoraproject.org/wiki/Packaging:DistTag
if ($IsCentOS) {
$rpm_dist = "el7"
} elseif ($IsFedora) {
$version_id = $LinuxInfo.VERSION_ID
$rpm_dist = "fedora.$version_id"
} elseif ($IsOpenSUSE) {
$version_id = $LinuxInfo.VERSION_ID
$rpm_dist = "suse.$version_id"
}
$Arguments = @(
"--force", "--verbose",
"--name", $Name,
"--version", $Version,
"--iteration", $Iteration,
"--maintainer", "PowerShell Team <PowerShellTeam@hotmail.com>",
"--vendor", "Microsoft Corporation",
"--url", "https://microsoft.com/powershell",
"--license", "MIT License",
"--description", $Description,
"--category", "shells",
"-t", $Type,
"-s", "dir"
)
if ($IsRedHatFamily) {
$Arguments += @("--rpm-dist", $rpm_dist)
$Arguments += @("--rpm-os", "linux")
}
foreach ($Dependency in $Dependencies) {
$Arguments += @("--depends", $Dependency)
}
if ($AfterInstallScript) {
$Arguments += @("--after-install", $AfterInstallScript)
}
if ($AfterRemoveScript) {
$Arguments += @("--after-remove", $AfterRemoveScript)
}
$Arguments += @(
2016-08-11 01:21:25 +02:00
"$Staging/=$Destination/",
"$GzipFile=$ManFile",
2016-08-11 01:21:25 +02:00
"/tmp/$Name=$Link"
)
# Build package
try {
$Output = Start-NativeExecution { fpm $Arguments }
} finally {
if ($IsOSX) {
# this is continuation of a fpm hack for a weird bug
if (Test-Path $hack_dest) {
Write-Warning "Move $hack_dest to $symlink_dest (fpm utime bug)"
Move-Item $hack_dest $symlink_dest
}
}
if ($AfterInstallScript) {
Remove-Item -erroraction 'silentlycontinue' $AfterInstallScript
}
if ($AfterRemoveScript) {
Remove-Item -erroraction 'silentlycontinue' $AfterRemoveScript
}
}
# Magic to get path output
$createdPackage = Get-Item (Join-Path $PSScriptRoot (($Output[-1] -split ":path=>")[-1] -replace '["{}]'))
if ($IsOSX) {
# Add the OS information to the OSX package file name.
$packageExt = [System.IO.Path]::GetExtension($createdPackage.Name)
$packageNameWithoutExt = [System.IO.Path]::GetFileNameWithoutExtension($createdPackage.Name)
$newPackageName = "{0}-{1}{2}" -f $packageNameWithoutExt, $script:Options.Runtime, $packageExt
$newPackagePath = Join-Path $createdPackage.DirectoryName $newPackageName
$createdPackage = Rename-Item $createdPackage.FullName $newPackagePath -PassThru
}
return $createdPackage
}
function Publish-NuGetFeed
{
param(
[string]$OutputPath = "$PSScriptRoot/nuget-artifacts",
[Parameter(Mandatory=$true)]
[string]$VersionSuffix
)
# Add .NET CLI tools to PATH
Find-Dotnet
if ($VersionSuffix) {
## NuGet/Home #3953, #4337 -- dotnet pack - version suffix missing from ProjectReference
## Workaround:
## dotnet restore /p:VersionSuffix=<suffix> # Bake the suffix into project.assets.json
## dotnet pack --version-suffix <suffix>
$TopProject = (New-PSOptions).Top
dotnet restore $TopProject "/p:VersionSuffix=$VersionSuffix"
}
2017-03-23 21:04:52 +01:00
try {
Push-Location $PSScriptRoot
@(
'Microsoft.PowerShell.Commands.Management',
'Microsoft.PowerShell.Commands.Utility',
'Microsoft.PowerShell.Commands.Diagnostics',
'Microsoft.PowerShell.ConsoleHost',
'Microsoft.PowerShell.Security',
2016-06-25 02:25:56 +02:00
'System.Management.Automation',
'Microsoft.PowerShell.CoreCLR.AssemblyLoadContext',
'Microsoft.PowerShell.CoreCLR.Eventing',
'Microsoft.WSMan.Management',
'Microsoft.WSMan.Runtime',
'Microsoft.PowerShell.SDK'
2017-03-23 21:04:52 +01:00
) | % {
if ($VersionSuffix) {
dotnet pack "src/$_" --output $OutputPath --version-suffix $VersionSuffix /p:IncludeSymbols=true
} else {
dotnet pack "src/$_" --output $OutputPath
}
}
2017-03-23 21:04:52 +01:00
} finally {
Pop-Location
}
}
function Start-DevPowerShell {
param(
[switch]$FullCLR,
[switch]$ZapDisable,
[string[]]$ArgumentList = '',
[switch]$LoadProfile,
[string]$binDir = (Split-Path (New-PSOptions -FullCLR:$FullCLR).Output),
[switch]$NoNewWindow,
[string]$Command,
[switch]$KeepPSModulePath
)
2017-03-23 21:04:52 +01:00
if ($FullCLR) {
## Stop building 'FullCLR', but keep the parameters and related scripts for now.
## Once we confirm that portable modules is supported with .NET Core 2.0, we will clean up all FullCLR related scripts.
throw "Building against FullCLR is not supported"
}
2016-04-02 07:01:05 +02:00
try {
if ((-not $NoNewWindow) -and ($IsCoreCLR)) {
Write-Warning "Start-DevPowerShell -NoNewWindow is currently implied in PowerShellCore edition https://github.com/PowerShell/PowerShell/issues/1543"
2016-07-27 19:55:42 +02:00
$NoNewWindow = $true
}
if (-not $LoadProfile) {
$ArgumentList = @('-noprofile') + $ArgumentList
}
if (-not $KeepPSModulePath) {
if (-not $Command) {
$ArgumentList = @('-NoExit') + $ArgumentList
}
$Command = '$env:PSModulePath = Join-Path $env:DEVPATH Modules; ' + $Command
}
if ($Command) {
$ArgumentList = $ArgumentList + @("-command $Command")
}
$env:DEVPATH = $binDir
2016-04-02 07:01:05 +02:00
if ($ZapDisable) {
$env:COMPLUS_ZapDisable = 1
}
if ($FullCLR -and (-not (Test-Path $binDir\powershell.exe.config))) {
$configContents = @"
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
2016-04-02 07:01:05 +02:00
<runtime>
<developmentMode developerInstallation="true"/>
</runtime>
</configuration>
"@
$configContents | Out-File -Encoding Ascii $binDir\powershell.exe.config
}
# splatting for the win
$startProcessArgs = @{
FilePath = "$binDir\powershell"
ArgumentList = "$ArgumentList"
}
if ($NoNewWindow) {
$startProcessArgs.NoNewWindow = $true
$startProcessArgs.Wait = $true
}
Start-Process @startProcessArgs
2016-04-02 07:01:05 +02:00
} finally {
if($env:DevPath)
{
Remove-Item env:DEVPATH
}
2017-01-16 22:31:14 +01:00
2016-04-02 07:01:05 +02:00
if ($ZapDisable) {
Remove-Item env:COMPLUS_ZapDisable
}
}
}
<#
.EXAMPLE
PS C:> Copy-MappedFiles -PslMonadRoot .\src\monad
copy files FROM .\src\monad (old location of submodule) TO src/<project> folders
#>
function Copy-MappedFiles {
2016-04-01 23:41:13 +02:00
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline=$true)]
[string[]]$Path = "$PSScriptRoot",
[Parameter(Mandatory=$true)]
[string]$PslMonadRoot,
[switch]$Force,
[switch]$WhatIf
)
begin {
function MaybeTerminatingWarning {
param([string]$Message)
if ($Force) {
Write-Warning "$Message : ignoring (-Force)"
} elseif ($WhatIf) {
Write-Warning "$Message : ignoring (-WhatIf)"
} else {
throw "$Message : use -Force to ignore"
}
}
if (-not (Test-Path -PathType Container $PslMonadRoot)) {
throw "$pslMonadRoot is not a valid folder"
}
2016-04-01 23:41:13 +02:00
Spelling comments (#2066) * spelling: comments in src/Microsoft.Management.Infrastructure.CimCmdlets * spelling: comments in src/Microsoft.PackageManagement.ArchiverProviders * spelling: comments in src/Microsoft.PackageManagement.CoreProviders * spelling: comments in src/Microsoft.PackageManagement.MetaProvider.PowerShell * spelling: comments in src/Microsoft.PackageManagement.MsiProvider * spelling: comments in src/Microsoft.PackageManagement.MsuProvider * spelling: comments in src/Microsoft.PackageManagement.NuGetProvider * spelling: comments in src/Microsoft.PackageManagement.PackageSourceListProvider * spelling: comments in src/Microsoft.PackageManagement * spelling: comments in src/Microsoft.PowerShell.Activities * spelling: comments in src/Microsoft.PowerShell.Commands.Diagnostics * spelling: comments in src/Microsoft.PowerShell.Commands.Management * spelling: comments in src/Microsoft.PowerShell.Commands.Utility * spelling: comments in src/Microsoft.PowerShell.ConsoleHost * spelling: comments in src/Microsoft.PowerShell.Core.Activities * spelling: comments in src/Microsoft.PowerShell.CoreCLR.AssemblyLoadContext * spelling: comments in src/Microsoft.PowerShell.CoreCLR.Eventing * spelling: comments in src/Microsoft.PowerShell.Diagnostics.Activities * spelling: comments in src/Microsoft.PowerShell.GraphicalHost * spelling: comments in src/Microsoft.PowerShell.LocalAccounts * spelling: comments in src/Microsoft.PowerShell.Management.Activities * spelling: comments in src/Microsoft.PowerShell.PSReadLine * spelling: comments in src/Microsoft.PowerShell.PackageManagement * spelling: comments in src/Microsoft.PowerShell.ScheduledJob * spelling: comments in src/Microsoft.PowerShell.Security.Activities * spelling: comments in src/Microsoft.PowerShell.Security * spelling: comments in src/Microsoft.PowerShell.Utility.Activities * spelling: comments in src/Microsoft.PowerShell.Workflow.ServiceCore * spelling: comments in src/Microsoft.WSMan.Management.Activities * spelling: comments in src/Modules * spelling: comments in src/Schemas * spelling: comments in src/libpsl-native * spelling: comments in src/powershell-native * spelling: comments in build.psm1 * spelling: comments in src/System.Management.Automation/CoreCLR * spelling: comments in src/System.Management.Automation/DscSupport * spelling: comments in src/System.Management.Automation/cimSupport * spelling: comments in src/System.Management.Automation/commands * spelling: comments in src/System.Management.Automation/engine/Modules
2016-08-26 22:46:03 +02:00
# Do some intelligence to prevent shooting us in the foot with CL management
# finding base-line CL
$cl = git --git-dir="$PSScriptRoot/.git" tag | % {if ($_ -match 'SD.(\d+)$') {[int]$Matches[1]} } | Sort-Object -Descending | Select-Object -First 1
if ($cl) {
log "Current base-line CL is SD:$cl (based on tags)"
} else {
MaybeTerminatingWarning "Could not determine base-line CL based on tags"
}
try {
Push-Location $PslMonadRoot
if (git status --porcelain -uno) {
MaybeTerminatingWarning "$pslMonadRoot has changes"
}
if (git log --grep="SD:$cl" HEAD^..HEAD) {
log "$pslMonadRoot HEAD matches [SD:$cl]"
} else {
Write-Warning "Try to checkout this commit in $pslMonadRoot :"
git log --grep="SD:$cl" | Write-Warning
MaybeTerminatingWarning "$pslMonadRoot HEAD doesn't match [SD:$cl]"
}
} finally {
Pop-Location
}
$map = @{}
}
process {
$map += Get-Mappings $Path -Root $PslMonadRoot
}
end {
$map.GetEnumerator() | % {
New-Item -ItemType Directory (Split-Path $_.Value) -ErrorAction SilentlyContinue > $null
Copy-Item $_.Key $_.Value -Verbose:([bool]$PSBoundParameters['Verbose']) -WhatIf:$WhatIf
}
}
}
function Get-Mappings
{
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline=$true)]
[string[]]$Path = "$PSScriptRoot",
[string]$Root,
[switch]$KeepRelativePaths
)
begin {
$mapFiles = @()
}
process {
Write-Verbose "Discovering map files in $Path"
$count = $mapFiles.Count
if (-not (Test-Path $Path)) {
throw "Mapping file not found in $mappingFilePath"
}
2016-04-01 23:41:13 +02:00
if (Test-Path -PathType Container $Path) {
$mapFiles += Get-ChildItem -Recurse $Path -Filter 'map.json' -File
} else {
# it exists and it's a file, don't check the name pattern
$mapFiles += Get-ChildItem $Path
}
Write-Verbose "Found $($mapFiles.Count - $count) map files in $Path"
}
end {
$map = @{}
$mapFiles | % {
$file = $_
try {
$rawHashtable = $_ | Get-Content -Raw | ConvertFrom-Json | Convert-PSObjectToHashtable
} catch {
Write-Error "Exception, when processing $($file.FullName): $_"
}
$mapRoot = Split-Path $_.FullName
if ($KeepRelativePaths) {
# not very elegant way to find relative for the current directory path
$mapRoot = $mapRoot.Substring($PSScriptRoot.Length + 1)
# keep original unix-style paths for git
$mapRoot = $mapRoot.Replace('\', '/')
}
$rawHashtable.GetEnumerator() | % {
$newKey = if ($Root) { Join-Path $Root $_.Key } else { $_.Key }
$newValue = if ($KeepRelativePaths) { ($mapRoot + '/' + $_.Value) } else { Join-Path $mapRoot $_.Value }
$map[$newKey] = $newValue
}
}
return $map
}
}
<#
.EXAMPLE Send-GitDiffToSd -diffArg1 32b90c048aa0c5bc8e67f96a98ea01c728c4a5be~1 -diffArg2 32b90c048aa0c5bc8e67f96a98ea01c728c4a5be -AdminRoot d:\e\ps_dev\admin
Spelling comments (#2066) * spelling: comments in src/Microsoft.Management.Infrastructure.CimCmdlets * spelling: comments in src/Microsoft.PackageManagement.ArchiverProviders * spelling: comments in src/Microsoft.PackageManagement.CoreProviders * spelling: comments in src/Microsoft.PackageManagement.MetaProvider.PowerShell * spelling: comments in src/Microsoft.PackageManagement.MsiProvider * spelling: comments in src/Microsoft.PackageManagement.MsuProvider * spelling: comments in src/Microsoft.PackageManagement.NuGetProvider * spelling: comments in src/Microsoft.PackageManagement.PackageSourceListProvider * spelling: comments in src/Microsoft.PackageManagement * spelling: comments in src/Microsoft.PowerShell.Activities * spelling: comments in src/Microsoft.PowerShell.Commands.Diagnostics * spelling: comments in src/Microsoft.PowerShell.Commands.Management * spelling: comments in src/Microsoft.PowerShell.Commands.Utility * spelling: comments in src/Microsoft.PowerShell.ConsoleHost * spelling: comments in src/Microsoft.PowerShell.Core.Activities * spelling: comments in src/Microsoft.PowerShell.CoreCLR.AssemblyLoadContext * spelling: comments in src/Microsoft.PowerShell.CoreCLR.Eventing * spelling: comments in src/Microsoft.PowerShell.Diagnostics.Activities * spelling: comments in src/Microsoft.PowerShell.GraphicalHost * spelling: comments in src/Microsoft.PowerShell.LocalAccounts * spelling: comments in src/Microsoft.PowerShell.Management.Activities * spelling: comments in src/Microsoft.PowerShell.PSReadLine * spelling: comments in src/Microsoft.PowerShell.PackageManagement * spelling: comments in src/Microsoft.PowerShell.ScheduledJob * spelling: comments in src/Microsoft.PowerShell.Security.Activities * spelling: comments in src/Microsoft.PowerShell.Security * spelling: comments in src/Microsoft.PowerShell.Utility.Activities * spelling: comments in src/Microsoft.PowerShell.Workflow.ServiceCore * spelling: comments in src/Microsoft.WSMan.Management.Activities * spelling: comments in src/Modules * spelling: comments in src/Schemas * spelling: comments in src/libpsl-native * spelling: comments in src/powershell-native * spelling: comments in build.psm1 * spelling: comments in src/System.Management.Automation/CoreCLR * spelling: comments in src/System.Management.Automation/DscSupport * spelling: comments in src/System.Management.Automation/cimSupport * spelling: comments in src/System.Management.Automation/commands * spelling: comments in src/System.Management.Automation/engine/Modules
2016-08-26 22:46:03 +02:00
Apply a single commit to admin folder
#>
2016-04-02 07:01:05 +02:00
function Send-GitDiffToSd {
param(
[Parameter(Mandatory)]
[string]$diffArg1,
[Parameter(Mandatory)]
[string]$diffArg2,
[Parameter(Mandatory)]
[string]$AdminRoot,
[switch]$WhatIf
)
# this is only for windows, because you cannot have SD enlistment on Linux
$patchPath = (ls (Join-Path (get-command git).Source '..\..') -Recurse -Filter 'patch.exe').FullName
$m = Get-Mappings -KeepRelativePaths -Root $AdminRoot
$affectedFiles = git diff --name-only $diffArg1 $diffArg2
$affectedFiles | % {
log "Changes in file $_"
}
$rev = Get-InvertedOrderedMap $m
foreach ($file in $affectedFiles) {
2016-04-02 07:01:05 +02:00
if ($rev.Contains) {
$sdFilePath = $rev[$file]
if (-not $sdFilePath)
{
Write-Warning "Cannot find mapped file for $file, skipping"
continue
}
$diff = git diff $diffArg1 $diffArg2 -- $file
2016-04-02 07:01:05 +02:00
if ($diff) {
log "Apply patch to $sdFilePath"
Set-Content -Value $diff -Path $env:TEMP\diff -Encoding Ascii
2016-04-02 07:01:05 +02:00
if ($WhatIf) {
log "Patch content"
Get-Content $env:TEMP\diff
2016-04-02 07:01:05 +02:00
} else {
2016-04-01 23:41:13 +02:00
& $patchPath --binary -p1 $sdFilePath $env:TEMP\diff
}
2016-04-02 07:01:05 +02:00
} else {
log "No changes in $file"
}
2016-04-02 07:01:05 +02:00
} else {
log "Ignore changes in $file, because there is no mapping for it"
}
2016-04-01 23:41:13 +02:00
}
}
2016-04-02 07:01:05 +02:00
function Start-TypeGen
{
[CmdletBinding()]
param()
# Add .NET CLI tools to PATH
Find-Dotnet
2017-03-23 21:04:52 +01:00
$GetDependenciesTargetPath = "$PSScriptRoot/src/Microsoft.PowerShell.SDK/obj/Microsoft.PowerShell.SDK.csproj.TypeCatalog.targets"
$GetDependenciesTargetValue = @'
<Project>
<Target Name="_GetDependencies"
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
DependsOnTargets="ResolveAssemblyReferencesDesignTime">
2017-03-23 21:04:52 +01:00
<ItemGroup>
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
<_RefAssemblyPath Include="%(_ReferencesFromRAR.ResolvedPath)%3B" Condition=" '%(_ReferencesFromRAR.Type)' == 'assembly' And '%(_ReferencesFromRAR.PackageName)' != 'Microsoft.Management.Infrastructure' " />
2017-03-23 21:04:52 +01:00
</ItemGroup>
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
<WriteLinesToFile File="$(_DependencyFile)" Lines="@(_RefAssemblyPath)" Overwrite="true" />
2017-03-23 21:04:52 +01:00
</Target>
</Project>
'@
Set-Content -Path $GetDependenciesTargetPath -Value $GetDependenciesTargetValue -Force -Encoding Ascii
Push-Location "$PSScriptRoot/src/Microsoft.PowerShell.SDK"
try {
2017-03-23 21:04:52 +01:00
$ps_inc_file = "$PSScriptRoot/src/TypeCatalogGen/powershell.inc"
dotnet msbuild .\Microsoft.PowerShell.SDK.csproj /t:_GetDependencies "/property:DesignTimeBuild=true;_DependencyFile=$ps_inc_file" /nologo
} finally {
Pop-Location
}
Push-Location "$PSScriptRoot/src/TypeCatalogGen"
try {
dotnet run ../Microsoft.PowerShell.CoreCLR.AssemblyLoadContext/CorePsTypeCatalog.cs powershell.inc
} finally {
Pop-Location
}
}
function Start-ResGen
{
[CmdletBinding()]
param()
# Add .NET CLI tools to PATH
Find-Dotnet
Push-Location "$PSScriptRoot/src/ResGen"
try {
Start-NativeExecution { dotnet run } | Write-Verbose
} finally {
Pop-Location
}
}
2016-04-02 07:01:05 +02:00
function Find-Dotnet() {
$originalPath = $env:PATH
$dotnetPath = if ($IsWindows) {
"$env:LocalAppData\Microsoft\dotnet"
} else {
"$env:HOME/.dotnet"
}
if (-not (precheck 'dotnet' "Could not find 'dotnet', appending $dotnetPath to PATH.")) {
$env:PATH += [IO.Path]::PathSeparator + $dotnetPath
}
if (-not (precheck 'dotnet' "Still could not find 'dotnet', restoring PATH.")) {
$env:PATH = $originalPath
}
}
<#
This is one-time conversion. We use it for to turn GetEventResources.txt into GetEventResources.resx
.EXAMPLE Convert-TxtResourceToXml -Path Microsoft.PowerShell.Commands.Diagnostics\resources
#>
function Convert-TxtResourceToXml
{
param(
[string[]]$Path
)
process {
$Path | % {
Get-ChildItem $_ -Filter "*.txt" | % {
$txtFile = $_.FullName
$resxFile = Join-Path (Split-Path $txtFile) "$($_.BaseName).resx"
$resourceHashtable = ConvertFrom-StringData (Get-Content -Raw $txtFile)
$resxContent = $resourceHashtable.GetEnumerator() | % {
@'
<data name="{0}" xml:space="preserve">
<value>{1}</value>
</data>
'@ -f $_.Key, $_.Value
} | Out-String
Set-Content -Path $resxFile -Value ($script:RESX_TEMPLATE -f $resxContent)
}
}
}
}
function Start-XamlGen
{
[CmdletBinding()]
param(
[Parameter()]
[ValidateSet("Debug", "Release")]
[string]
$MSBuildConfiguration = "Release"
)
Use-MSBuild
Get-ChildItem -Path "$PSScriptRoot/src" -Directory | % {
$XamlDir = Join-Path -Path $_.FullName -ChildPath Xamls
if ((Test-Path -Path $XamlDir -PathType Container) -and
(@(Get-ChildItem -Path "$XamlDir\*.xaml").Count -gt 0)) {
$OutputDir = Join-Path -Path $env:TEMP -ChildPath "_Resolve_Xaml_"
Remove-Item -Path $OutputDir -Recurse -Force -ErrorAction SilentlyContinue
mkdir -Path $OutputDir -Force > $null
# we will get failures, but it's ok: we only need to copy *.g.cs files in the dotnet cli project.
$SourceDir = ConvertFrom-Xaml -Configuration $MSBuildConfiguration -OutputDir $OutputDir -XamlDir $XamlDir -IgnoreMsbuildFailure:$true
$DestinationDir = Join-Path -Path $_.FullName -ChildPath gen
New-Item -ItemType Directory $DestinationDir -ErrorAction SilentlyContinue > $null
$filesToCopy = Get-Item "$SourceDir\*.cs", "$SourceDir\*.g.resources"
if (-not $filesToCopy) {
throw "No .cs or .g.resources files are generated for $XamlDir, something went wrong. Run 'Start-XamlGen -Verbose' for details."
}
$filesToCopy | % {
$sourcePath = $_.FullName
Write-Verbose "Copy generated xaml artifact: $sourcePath -> $DestinationDir"
Copy-Item -Path $sourcePath -Destination $DestinationDir
}
}
}
}
$Script:XamlProj = @"
<Project DefaultTargets="ResolveAssemblyReferences;MarkupCompilePass1;PrepareResources" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Language>C#</Language>
<AssemblyName>Microsoft.PowerShell.Activities</AssemblyName>
<OutputType>library</OutputType>
<Configuration>{0}</Configuration>
<Platform>Any CPU</Platform>
<OutputPath>{1}</OutputPath>
<Do_CodeGenFromXaml>true</Do_CodeGenFromXaml>
</PropertyGroup>
<Import Project="`$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<Import Project="`$(MSBuildBinPath)\Microsoft.WinFX.targets" Condition="'`$(TargetFrameworkVersion)' == 'v2.0' OR '`$(TargetFrameworkVersion)' == 'v3.0' OR '`$(TargetFrameworkVersion)' == 'v3.5'" />
<ItemGroup>
{2}
<Reference Include="WindowsBase.dll">
<Private>False</Private>
</Reference>
<Reference Include="PresentationCore.dll">
<Private>False</Private>
</Reference>
<Reference Include="PresentationFramework.dll">
<Private>False</Private>
</Reference>
</ItemGroup>
</Project>
"@
$Script:XamlProjPage = @'
<Page Include="{0}" />
'@
function script:ConvertFrom-Xaml {
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string] $Configuration,
[Parameter(Mandatory=$true)]
[string] $OutputDir,
[Parameter(Mandatory=$true)]
[string] $XamlDir,
[switch] $IgnoreMsbuildFailure
)
log "ConvertFrom-Xaml for $XamlDir"
$Pages = ""
Get-ChildItem -Path "$XamlDir\*.xaml" | % {
$Page = $Script:XamlProjPage -f $_.FullName
$Pages += $Page
}
$XamlProjContent = $Script:XamlProj -f $Configuration, $OutputDir, $Pages
$XamlProjPath = Join-Path -Path $OutputDir -ChildPath xaml.proj
Set-Content -Path $XamlProjPath -Value $XamlProjContent -Encoding Ascii -NoNewline -Force
msbuild $XamlProjPath | Write-Verbose
if ($LASTEXITCODE -ne 0) {
$message = "When processing $XamlDir 'msbuild $XamlProjPath > `$null' failed with exit code $LASTEXITCODE"
if ($IgnoreMsbuildFailure) {
Write-Verbose $message
} else {
throw $message
}
}
return (Join-Path -Path $OutputDir -ChildPath "obj\Any CPU\$Configuration")
}
function script:Use-MSBuild {
# TODO: we probably should require a particular version of msbuild, if we are taking this dependency
# msbuild v14 and msbuild v4 behaviors are different for XAML generation
$frameworkMsBuildLocation = "${env:SystemRoot}\Microsoft.Net\Framework\v4.0.30319\msbuild"
$msbuild = get-command msbuild -ErrorAction SilentlyContinue
if ($msbuild) {
# all good, nothing to do
return
}
if (-not (Test-Path $frameworkMsBuildLocation)) {
throw "msbuild not found in '$frameworkMsBuildLocation'. Install Visual Studio 2015."
}
Set-Alias msbuild $frameworkMsBuildLocation -Scope Script
}
2016-04-02 07:01:05 +02:00
function script:log([string]$message) {
Write-Host -Foreground Green $message
Spelling comments (#2066) * spelling: comments in src/Microsoft.Management.Infrastructure.CimCmdlets * spelling: comments in src/Microsoft.PackageManagement.ArchiverProviders * spelling: comments in src/Microsoft.PackageManagement.CoreProviders * spelling: comments in src/Microsoft.PackageManagement.MetaProvider.PowerShell * spelling: comments in src/Microsoft.PackageManagement.MsiProvider * spelling: comments in src/Microsoft.PackageManagement.MsuProvider * spelling: comments in src/Microsoft.PackageManagement.NuGetProvider * spelling: comments in src/Microsoft.PackageManagement.PackageSourceListProvider * spelling: comments in src/Microsoft.PackageManagement * spelling: comments in src/Microsoft.PowerShell.Activities * spelling: comments in src/Microsoft.PowerShell.Commands.Diagnostics * spelling: comments in src/Microsoft.PowerShell.Commands.Management * spelling: comments in src/Microsoft.PowerShell.Commands.Utility * spelling: comments in src/Microsoft.PowerShell.ConsoleHost * spelling: comments in src/Microsoft.PowerShell.Core.Activities * spelling: comments in src/Microsoft.PowerShell.CoreCLR.AssemblyLoadContext * spelling: comments in src/Microsoft.PowerShell.CoreCLR.Eventing * spelling: comments in src/Microsoft.PowerShell.Diagnostics.Activities * spelling: comments in src/Microsoft.PowerShell.GraphicalHost * spelling: comments in src/Microsoft.PowerShell.LocalAccounts * spelling: comments in src/Microsoft.PowerShell.Management.Activities * spelling: comments in src/Microsoft.PowerShell.PSReadLine * spelling: comments in src/Microsoft.PowerShell.PackageManagement * spelling: comments in src/Microsoft.PowerShell.ScheduledJob * spelling: comments in src/Microsoft.PowerShell.Security.Activities * spelling: comments in src/Microsoft.PowerShell.Security * spelling: comments in src/Microsoft.PowerShell.Utility.Activities * spelling: comments in src/Microsoft.PowerShell.Workflow.ServiceCore * spelling: comments in src/Microsoft.WSMan.Management.Activities * spelling: comments in src/Modules * spelling: comments in src/Schemas * spelling: comments in src/libpsl-native * spelling: comments in src/powershell-native * spelling: comments in build.psm1 * spelling: comments in src/System.Management.Automation/CoreCLR * spelling: comments in src/System.Management.Automation/DscSupport * spelling: comments in src/System.Management.Automation/cimSupport * spelling: comments in src/System.Management.Automation/commands * spelling: comments in src/System.Management.Automation/engine/Modules
2016-08-26 22:46:03 +02:00
#reset colors for older package to at return to default after error message on a compilation error
[console]::ResetColor()
2016-04-02 07:01:05 +02:00
}
function script:logerror([string]$message) {
Write-Host -Foreground Red $message
#reset colors for older package to at return to default after error message on a compilation error
[console]::ResetColor()
}
2016-04-02 07:01:05 +02:00
function script:precheck([string]$command, [string]$missedMessage) {
$c = Get-Command $command -ErrorAction SilentlyContinue
if (-not $c) {
if ($missedMessage -ne $null)
{
Write-Warning $missedMessage
}
2016-04-02 07:01:05 +02:00
return $false
} else {
return $true
}
}
function script:Get-InvertedOrderedMap {
param(
$h
)
$res = [ordered]@{}
foreach ($q in $h.GetEnumerator()) {
if ($res.Contains($q.Value)) {
throw "Cannot invert hashtable: duplicated key $($q.Value)"
}
$res[$q.Value] = $q.Key
}
return $res
}
## this function is from Dave Wyatt's answer on
## http://stackoverflow.com/questions/22002748/hashtables-from-convertfrom-json-have-different-type-from-powershells-built-in-h
function script:Convert-PSObjectToHashtable {
param (
[Parameter(ValueFromPipeline)]
$InputObject
)
process {
if ($null -eq $InputObject) { return $null }
if ($InputObject -is [System.Collections.IEnumerable] -and $InputObject -isnot [string]) {
$collection = @(
foreach ($object in $InputObject) { Convert-PSObjectToHashtable $object }
)
Write-Output -NoEnumerate $collection
} elseif ($InputObject -is [psobject]) {
$hash = @{}
foreach ($property in $InputObject.PSObject.Properties) {
2016-04-02 07:01:05 +02:00
$hash[$property.Name] = Convert-PSObjectToHashtable $property.Value
}
$hash
} else {
$InputObject
}
}
}
# this function wraps native command Execution
# for more information, read https://mnaoumov.wordpress.com/2015/01/11/execution-of-external-commands-in-powershell-done-right/
function script:Start-NativeExecution([scriptblock]$sb, [switch]$IgnoreExitcode)
{
$backupEAP = $script:ErrorActionPreference
$script:ErrorActionPreference = "Continue"
try {
& $sb
Spelling comments (#2066) * spelling: comments in src/Microsoft.Management.Infrastructure.CimCmdlets * spelling: comments in src/Microsoft.PackageManagement.ArchiverProviders * spelling: comments in src/Microsoft.PackageManagement.CoreProviders * spelling: comments in src/Microsoft.PackageManagement.MetaProvider.PowerShell * spelling: comments in src/Microsoft.PackageManagement.MsiProvider * spelling: comments in src/Microsoft.PackageManagement.MsuProvider * spelling: comments in src/Microsoft.PackageManagement.NuGetProvider * spelling: comments in src/Microsoft.PackageManagement.PackageSourceListProvider * spelling: comments in src/Microsoft.PackageManagement * spelling: comments in src/Microsoft.PowerShell.Activities * spelling: comments in src/Microsoft.PowerShell.Commands.Diagnostics * spelling: comments in src/Microsoft.PowerShell.Commands.Management * spelling: comments in src/Microsoft.PowerShell.Commands.Utility * spelling: comments in src/Microsoft.PowerShell.ConsoleHost * spelling: comments in src/Microsoft.PowerShell.Core.Activities * spelling: comments in src/Microsoft.PowerShell.CoreCLR.AssemblyLoadContext * spelling: comments in src/Microsoft.PowerShell.CoreCLR.Eventing * spelling: comments in src/Microsoft.PowerShell.Diagnostics.Activities * spelling: comments in src/Microsoft.PowerShell.GraphicalHost * spelling: comments in src/Microsoft.PowerShell.LocalAccounts * spelling: comments in src/Microsoft.PowerShell.Management.Activities * spelling: comments in src/Microsoft.PowerShell.PSReadLine * spelling: comments in src/Microsoft.PowerShell.PackageManagement * spelling: comments in src/Microsoft.PowerShell.ScheduledJob * spelling: comments in src/Microsoft.PowerShell.Security.Activities * spelling: comments in src/Microsoft.PowerShell.Security * spelling: comments in src/Microsoft.PowerShell.Utility.Activities * spelling: comments in src/Microsoft.PowerShell.Workflow.ServiceCore * spelling: comments in src/Microsoft.WSMan.Management.Activities * spelling: comments in src/Modules * spelling: comments in src/Schemas * spelling: comments in src/libpsl-native * spelling: comments in src/powershell-native * spelling: comments in build.psm1 * spelling: comments in src/System.Management.Automation/CoreCLR * spelling: comments in src/System.Management.Automation/DscSupport * spelling: comments in src/System.Management.Automation/cimSupport * spelling: comments in src/System.Management.Automation/commands * spelling: comments in src/System.Management.Automation/engine/Modules
2016-08-26 22:46:03 +02:00
# note, if $sb doesn't have a native invocation, $LASTEXITCODE will
# point to the obsolete value
if ($LASTEXITCODE -ne 0 -and -not $IgnoreExitcode) {
throw "Execution of {$sb} failed with exit code $LASTEXITCODE"
}
} finally {
$script:ErrorActionPreference = $backupEAP
}
}
# 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
{
[CmdletBinding()]
param (
# Version of the Package
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $Version
)
Write-Verbose "Extract the version in the form of major.minor[.build[.revision]] for $Version"
$packageVersionTokens = $Version.Split('-')
$packageVersion = ([regex]::matches($Version, "\d+(\.\d+)+"))[0].value
if (1 -eq $packageVersionTokens.Count) {
# In case the input is of the form a.b.c, add a '0' at the end for revision field
$packageVersion = $packageVersion + '.0'
} elseif (1 -lt $packageVersionTokens.Count) {
# We have all the four fields
$packageBuildTokens = ([regex]::Matches($packageVersionTokens[1], "\d+"))[0].value
$packageVersion = $packageVersion + '.' + $packageBuildTokens
}
$packageVersion
}
function New-MSIPackage
2016-05-24 23:23:38 +02:00
{
[CmdletBinding()]
param (
2017-01-16 22:31:14 +01:00
2016-05-24 23:23:38 +02:00
# Name of the Product
[ValidateNotNullOrEmpty()]
[string] $ProductName = 'PowerShell',
# Suffix of the Name
[string] $ProductNameSuffix,
2016-05-24 23:23:38 +02:00
# Version of the Product
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $ProductVersion,
# Product Guid needs to change for every version to support SxS install
[ValidateNotNullOrEmpty()]
[string] $ProductGuid = 'a5249933-73a1-4b10-8a4c-13c98bdc16fe',
# Source Path to the Product Files - required to package the contents into an MSI
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $ProductSourcePath,
# File describing the MSI Package creation semantics
[ValidateNotNullOrEmpty()]
[string] $ProductWxsPath = "$PSScriptRoot\assets\Product.wxs",
2016-06-27 20:39:49 +02:00
# Path to Assets folder containing artifacts such as icons, images
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
2017-01-16 22:31:14 +01:00
[string] $AssetsPath,
2016-05-24 23:23:38 +02:00
2016-08-04 22:30:00 +02:00
# Path to license.rtf file - for the EULA
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
2016-11-16 19:32:21 +01:00
[string] $LicenseFilePath,
# Architecture to use when creating the MSI
[Parameter(Mandatory = $true)]
[ValidateSet("x86", "x64")]
[ValidateNotNullOrEmpty()]
[string] $ProductTargetArchitecture
2016-08-04 22:30:00 +02:00
)
2016-05-24 23:23:38 +02:00
## AppVeyor base image might update the version for Wix. Hence, we should
## not hard code version numbers.
$wixToolsetBinPath = "${env:ProgramFiles(x86)}\WiX Toolset *\bin"
2016-05-24 23:23:38 +02:00
Write-Verbose "Ensure Wix Toolset is present on the machine @ $wixToolsetBinPath"
2016-08-04 22:30:00 +02:00
if (-not (Test-Path $wixToolsetBinPath))
{
throw "Wix Toolset is required to create MSI package. Please install Wix from https://wix.codeplex.com/downloads/get/1540240"
2016-05-24 23:23:38 +02:00
}
## Get the latest if multiple versions exist.
$wixToolsetBinPath = (Get-ChildItem $wixToolsetBinPath).FullName | Sort-Object -Descending | Select-Object -First 1
2016-05-24 23:23:38 +02:00
Write-Verbose "Initialize Wix executables - Heat.exe, Candle.exe, Light.exe"
$wixHeatExePath = Join-Path $wixToolsetBinPath "Heat.exe"
$wixCandleExePath = Join-Path $wixToolsetBinPath "Candle.exe"
$wixLightExePath = Join-Path $wixToolsetBinPath "Light.exe"
2016-06-27 20:39:49 +02:00
$ProductSemanticVersion = Get-PackageSemanticVersion -Version $ProductVersion
$ProductVersion = Get-PackageVersionAsMajorMinorBuildRevision -Version $ProductVersion
2017-01-16 22:31:14 +01:00
2016-06-27 20:39:49 +02:00
$assetsInSourcePath = Join-Path $ProductSourcePath 'assets'
New-Item $assetsInSourcePath -type directory -Force | Write-Verbose
2016-06-27 20:39:49 +02:00
2017-01-16 22:31:14 +01:00
Write-Verbose "Place dependencies such as icons to $assetsInSourcePath"
2016-06-27 20:39:49 +02:00
Copy-Item "$AssetsPath\*.ico" $assetsInSourcePath -Force
2017-01-16 22:31:14 +01:00
$productVersionWithName = $ProductName + '_' + $ProductVersion
$productSemanticVersionWithName = $ProductName + '-' + $ProductSemanticVersion
2017-01-16 22:31:14 +01:00
Write-Verbose "Create MSI for Product $productSemanticVersionWithName"
2016-05-24 23:23:38 +02:00
[Environment]::SetEnvironmentVariable("ProductSourcePath", $ProductSourcePath, "Process")
# These variables are used by Product.wxs in assets directory
2016-05-24 23:23:38 +02:00
[Environment]::SetEnvironmentVariable("ProductName", $ProductName, "Process")
[Environment]::SetEnvironmentVariable("ProductGuid", $ProductGuid, "Process")
[Environment]::SetEnvironmentVariable("ProductVersion", $ProductVersion, "Process")
[Environment]::SetEnvironmentVariable("ProductSemanticVersion", $ProductSemanticVersion, "Process")
[Environment]::SetEnvironmentVariable("ProductVersionWithName", $productVersionWithName, "Process")
2016-11-16 19:32:21 +01:00
[Environment]::SetEnvironmentVariable("ProductTargetArchitecture", $ProductTargetArchitecture, "Process")
$ProductProgFilesDir = "ProgramFiles64Folder"
if ($ProductTargetArchitecture -eq "x86")
{
$ProductProgFilesDir = "ProgramFilesFolder"
}
[Environment]::SetEnvironmentVariable("ProductProgFilesDir", $ProductProgFilesDir, "Process")
2016-05-24 23:23:38 +02:00
$wixFragmentPath = (Join-path $env:Temp "Fragment.wxs")
$wixObjProductPath = (Join-path $env:Temp "Product.wixobj")
$wixObjFragmentPath = (Join-path $env:Temp "Fragment.wixobj")
$packageName = $productSemanticVersionWithName
if ($ProductNameSuffix) {
$packageName += "-$ProductNameSuffix"
}
2017-01-16 22:31:14 +01:00
$msiLocationPath = Join-Path $pwd "$packageName.msi"
2016-05-24 23:41:23 +02:00
Remove-Item -ErrorAction SilentlyContinue $msiLocationPath -Force
2016-05-24 23:23:38 +02:00
& $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
& $wixLightExePath -out $msiLocationPath $wixObjProductPath $wixObjFragmentPath -ext WixUIExtension -ext WixUtilExtension -dWixUILicenseRtf="$LicenseFilePath" -v | Write-Verbose
2017-01-16 22:31:14 +01:00
2016-05-24 23:41:23 +02:00
Remove-Item -ErrorAction SilentlyContinue *.wixpdb -Force
2016-05-24 23:23:38 +02:00
Write-Verbose "You can find the MSI @ $msiLocationPath" -Verbose
$msiLocationPath
2016-05-24 23:23:38 +02:00
}
2016-06-02 19:31:02 +02:00
# Function to create an Appx package compatible with Windows 8.1 and above
function New-AppxPackage
{
[CmdletBinding()]
param (
2016-06-02 19:31:02 +02:00
# Name of the Package
[ValidateNotNullOrEmpty()]
[string] $PackageName = 'PowerShell',
2016-06-02 19:31:02 +02:00
# Suffix of the Name
[string] $PackageNameSuffix,
2016-06-02 19:31:02 +02:00
# Version of the Package
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageVersion,
2016-06-02 19:31:02 +02:00
# Source Path to the Binplaced Files
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageSourcePath,
2016-06-02 19:31:02 +02:00
# Path to Assets folder containing Appx specific artifacts
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $AssetsPath
2016-06-02 19:31:02 +02:00
)
2017-01-16 22:31:14 +01:00
$PackageSemanticVersion = Get-PackageSemanticVersion -Version $PackageVersion
$PackageVersion = Get-PackageVersionAsMajorMinorBuildRevision -Version $PackageVersion
2016-06-02 19:31:02 +02:00
Write-Verbose "Package Version is $PackageVersion"
$win10sdkBinPath = Get-Win10SDKBinDir
2016-06-02 19:31:02 +02:00
Write-Verbose "Ensure Win10 SDK is present on the machine @ $win10sdkBinPath"
if (-not (Test-Win10SDK)) {
2016-06-02 19:31:02 +02:00
throw "Install Win10 SDK prior to running this script - https://go.microsoft.com/fwlink/p/?LinkID=698771"
}
Write-Verbose "Ensure Source Path is valid - $PackageSourcePath"
if (-not (Test-Path $PackageSourcePath)) {
throw "Invalid PackageSourcePath - $PackageSourcePath"
2016-06-02 19:31:02 +02:00
}
Write-Verbose "Ensure Assets Path is valid - $AssetsPath"
if (-not (Test-Path $AssetsPath)) {
2016-06-02 19:31:02 +02:00
throw "Invalid AssetsPath - $AssetsPath"
}
2016-06-02 19:31:02 +02:00
Write-Verbose "Initialize MakeAppx executable path"
$makeappxExePath = Join-Path $win10sdkBinPath "MakeAppx.exe"
$appxManifest = @"
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities">
2016-06-27 20:39:49 +02:00
<Identity Name="Microsoft.PowerShell" ProcessorArchitecture="x64" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" Version="#VERSION#" />
2016-06-02 19:31:02 +02:00
<Properties>
2016-06-27 20:39:49 +02:00
<DisplayName>PowerShell</DisplayName>
2016-06-02 19:31:02 +02:00
<PublisherDisplayName>Microsoft Corporation</PublisherDisplayName>
<Logo>#LOGO#</Logo>
</Properties>
<Resources>
<Resource Language="en-us" />
</Resources>
<Dependencies>
<TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.14257.0" MaxVersionTested="12.0.0.0" />
<TargetDeviceFamily Name="Windows.Server" MinVersion="10.0.14257.0" MaxVersionTested="12.0.0.0" />
</Dependencies>
<Capabilities>
<rescap:Capability Name="runFullTrust" />
</Capabilities>
<Applications>
2016-06-27 20:39:49 +02:00
<Application Id="PowerShell" Executable="powershell.exe" EntryPoint="Windows.FullTrustApplication">
<uap:VisualElements DisplayName="PowerShell" Description="PowerShell for every system" BackgroundColor="transparent" Square150x150Logo="#SQUARE150x150LOGO#" Square44x44Logo="#SQUARE44x44LOGO#">
2016-06-02 19:31:02 +02:00
</uap:VisualElements>
</Application>
</Applications>
</Package>
"@
$appxManifest = $appxManifest.Replace('#VERSION#', $PackageVersion)
$appxManifest = $appxManifest.Replace('#LOGO#', 'Assets\Powershell_256.png')
$appxManifest = $appxManifest.Replace('#SQUARE150x150LOGO#', 'Assets\Powershell_256.png')
$appxManifest = $appxManifest.Replace('#SQUARE44x44LOGO#', 'Assets\Powershell_48.png')
Write-Verbose "Place Appx Manifest in $PackageSourcePath"
$appxManifest | Out-File "$PackageSourcePath\AppxManifest.xml" -Force
$assetsInSourcePath = Join-Path $PackageSourcePath 'Assets'
New-Item $assetsInSourcePath -type directory -Force | Out-Null
2016-06-02 19:31:02 +02:00
Write-Verbose "Place AppxManifest dependencies such as images to $assetsInSourcePath"
2016-06-02 19:31:02 +02:00
Copy-Item "$AssetsPath\*.png" $assetsInSourcePath -Force
$appxPackageName = $PackageName + "-" + $PackageSemanticVersion
if ($PackageNameSuffix) {
$appxPackageName = $appxPackageName, $PackageNameSuffix -join "-"
}
$appxLocationPath = "$pwd\$appxPackageName.appx"
Write-Verbose "Calling MakeAppx from $makeappxExePath to create the package @ $appxLocationPath"
& $makeappxExePath pack /o /v /d $PackageSourcePath /p $appxLocationPath | Write-Verbose
2016-06-02 19:31:02 +02:00
Write-Verbose "Clean-up Appx artifacts and Assets from $SourcePath"
2016-06-02 19:31:02 +02:00
Remove-Item $assetsInSourcePath -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item "$PackageSourcePath\AppxManifest.xml" -Force -ErrorAction SilentlyContinue
Write-Verbose "You can find the APPX @ $appxLocationPath" -Verbose
$appxLocationPath
}
2016-06-02 19:31:02 +02:00
# Function to create a zip file for Nano Server and xcopy deployment
function New-ZipPackage
{
[CmdletBinding()]
param (
2017-01-16 22:31:14 +01:00
# Name of the Product
[ValidateNotNullOrEmpty()]
[string] $PackageName = 'PowerShell',
# Suffix of the Name
[string] $PackageNameSuffix,
# Version of the Product
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageVersion,
# Source Path to the Product Files - required to package the contents into an Zip
[Parameter(Mandatory = $true)]
[ValidateNotNullOrEmpty()]
[string] $PackageSourcePath
)
$ProductSemanticVersion = Get-PackageSemanticVersion -Version $PackageVersion
2017-01-16 22:31:14 +01:00
$zipPackageName = $PackageName + "-" + $ProductSemanticVersion
if ($PackageNameSuffix) {
$zipPackageName = $zipPackageName, $PackageNameSuffix -join "-"
}
2017-01-16 22:31:14 +01:00
Write-Verbose "Create Zip for Product $zipPackageName"
$zipLocationPath = Join-Path $PWD "$zipPackageName.zip"
If(Get-Command Compress-Archive -ErrorAction Ignore)
{
Compress-Archive -Path $PackageSourcePath\* -DestinationPath $zipLocationPath
Write-Verbose "You can find the Zip @ $zipLocationPath" -Verbose
$zipLocationPath
}
2017-01-16 22:31:14 +01:00
#TODO: Use .NET Api to do compresss-archive equivalent if the cmdlet is not present
else
{
Write-Error -Message "Compress-Archive cmdlet is missing in this PowerShell version"
}
2016-06-02 19:31:02 +02:00
}
2016-08-02 22:33:51 +02:00
function Start-CrossGen {
[CmdletBinding()]
param(
[Parameter(Mandatory= $true)]
[ValidateNotNullOrEmpty()]
[String]
2016-11-20 21:59:50 +01:00
$PublishPath,
[Parameter(Mandatory=$true)]
[ValidateSet("ubuntu.14.04-x64",
"ubuntu.16.04-x64",
"debian.8-x64",
"centos.7-x64",
"fedora.24-x64",
2016-11-20 21:59:50 +01:00
"win7-x86",
"win7-x64",
"win81-x64",
"win10-x64",
"osx.10.11-x64",
"osx.10.12-x64",
"opensuse.13.2-x64",
"opensuse.42.1-x64")]
2016-11-20 21:59:50 +01:00
[string]
$Runtime
2016-08-02 22:33:51 +02:00
)
2016-08-02 22:33:51 +02:00
function Generate-CrossGenAssembly {
param (
[Parameter(Mandatory= $true)]
[ValidateNotNullOrEmpty()]
[String]
$AssemblyPath,
[Parameter(Mandatory= $true)]
[ValidateNotNullOrEmpty()]
[String]
$CrossgenPath
)
$outputAssembly = $AssemblyPath.Replace(".dll", ".ni.dll")
$platformAssembliesPath = Split-Path $AssemblyPath -Parent
$crossgenFolder = Split-Path $CrossgenPath
$niAssemblyName = Split-Path $outputAssembly -Leaf
try {
2016-08-02 22:33:51 +02:00
Push-Location $crossgenFolder
# Generate the ngen assembly
Write-Verbose "Generating assembly $niAssemblyName"
2016-08-02 22:33:51 +02:00
Start-NativeExecution {
2016-08-03 09:19:39 +02:00
& $CrossgenPath /MissingDependenciesOK /in $AssemblyPath /out $outputAssembly /Platform_Assemblies_Paths $platformAssembliesPath
} | Write-Verbose
2016-08-02 22:33:51 +02:00
<#
# TODO: Generate the pdb for the ngen binary - currently, there is a hard dependency on diasymreader.dll, which is available at %windir%\Microsoft.NET\Framework\v4.0.30319.
# However, we still need to figure out the prerequisites on Linux.
Start-NativeExecution {
2016-08-03 09:19:39 +02:00
& $CrossgenPath /Platform_Assemblies_Paths $platformAssembliesPath /CreatePDB $platformAssembliesPath /lines $platformAssembliesPath $niAssemblyName
} | Write-Verbose
2016-08-02 22:33:51 +02:00
#>
} finally {
2016-08-02 22:33:51 +02:00
Pop-Location
}
}
if (-not (Test-Path $PublishPath)) {
2016-08-02 22:33:51 +02:00
throw "Path '$PublishPath' does not exist."
}
# Get the path to crossgen
2017-01-17 22:00:52 +01:00
$crossGenExe = if ($IsWindows) { "crossgen.exe" } else { "crossgen" }
2016-08-02 22:33:51 +02:00
2016-08-03 21:05:26 +02:00
# The crossgen tool is only published for these particular runtimes
$crossGenRuntime = if ($IsWindows) {
2016-11-20 21:59:50 +01:00
if ($Runtime -match "-x86") {
"win-x86"
2016-11-20 21:59:50 +01:00
} else {
"win-x64"
2016-11-20 21:59:50 +01:00
}
2016-08-03 21:05:26 +02:00
} elseif ($IsLinux) {
Move powershell to .NET Core 2.0 (#3556) This change moves powershell to .NET Core 2.0. Major changes are: 1. PowerShell assemblies are now targeting `netcoreapp2.0`. We are using `microsoft.netcore.app-2.0.0-preview1-001913-00`, which is from dotnet-core build 4/4/17. We cannot target `netstandard2.0` because the packages `System.Reflection.Emit` and `System.Reflection.Emit.Lightweight`, which are needed for powershell class, cannot be referenced when targeting `netstandard2.0`. 2. Refactor code to remove most CLR stub types and extension types. 3. Update build scripts to enable CI builds. The `-cache` section is specified to depend on `appveyor.yml`, so the cache will be invalidated if `appveyor.yml` is changed. 4. Ship `netcoreapp` reference assemblies with powershell to fix the issues in `Add-Type` (#2764). By default `Add-Type` will reference all those reference assemblies when compiling C# code. If `-ReferenceAssembly` is specified, then we search reference assemblies first, then the framework runtime assemblies, and lastly the loaded assemblies (possibly a third-party one that was already loaded). 5. `dotnet publish` generates executable on Unix platforms, but doesn't set "x" permission and thus it cannot execute. Currently, the "x" permission is set in the build script, `dotnet/cli` issue [#6286](https://github.com/dotnet/cli/issues/6286) is tracking this. 6. Replace the use of some APIs with the ones that take `SecureString`. 7. osx.10.12 is required to update to `netcoreapp2.0` because `dotnet-cli` 2.0.0-preview only works on osx.10.12. 8. Add dependency to `System.ValueTuple` to work around a ambiguous type identity issue in coreclr. The issue is tracked by `dotnet/corefx` [#17797](https://github.com/dotnet/corefx/issues/17797). When moving to newer version of `netcoreapp2.0`, we need to verify if this dependency is still needed.
2017-04-17 20:52:38 +02:00
"linux-x64"
2016-08-03 21:05:26 +02:00
} elseif ($IsOSX) {
"osx-x64"
2016-08-03 21:05:26 +02:00
}
if (-not $crossGenRuntime) {
throw "crossgen is not available for this platform"
}
# Get the CrossGen.exe for the correct runtime with the latest version
2017-01-17 22:00:52 +01:00
$crossGenPath = Get-ChildItem $script:nugetPackagesRoot $crossGenExe -Recurse | `
Where-Object { $_.FullName -match $crossGenRuntime } | `
Sort-Object -Property FullName -Descending | `
Select-Object -First 1 | `
ForEach-Object { $_.FullName }
2016-08-03 21:05:26 +02:00
if (-not $crossGenPath) {
2016-08-02 22:33:51 +02:00
throw "Unable to find latest version of crossgen.exe. 'Please run Start-PSBuild -Clean' first, and then try again."
}
2016-11-20 21:59:50 +01:00
Write-Verbose "Matched CrossGen.exe: $crossGenPath" -Verbose
2016-08-02 22:33:51 +02:00
# 'x' permission is not set for packages restored on Linux/OSX.
# this is temporary workaround to a bug in dotnet.exe, tracking by dotnet/cli issue #6286
if ($IsLinux -or $IsOSX) {
chmod u+x $crossGenPath
}
2016-08-02 22:33:51 +02:00
# Crossgen.exe requires the following assemblies:
# mscorlib.dll
# System.Private.CoreLib.dll
# clrjit.dll on Windows or libclrjit.so/dylib on Linux/OS X
2016-08-02 22:33:51 +02:00
$crossGenRequiredAssemblies = @("mscorlib.dll", "System.Private.CoreLib.dll")
$crossGenRequiredAssemblies += if ($IsWindows) {
"clrjit.dll"
} elseif ($IsLinux) {
"libclrjit.so"
} elseif ($IsOSX) {
"libclrjit.dylib"
2016-08-02 22:33:51 +02:00
}
# Make sure that all dependencies required by crossgen are at the directory.
2016-08-02 22:33:51 +02:00
$crossGenFolder = Split-Path $crossGenPath
foreach ($assemblyName in $crossGenRequiredAssemblies) {
if (-not (Test-Path "$crossGenFolder\$assemblyName")) {
2016-08-02 22:33:51 +02:00
Copy-Item -Path "$PublishPath\$assemblyName" -Destination $crossGenFolder -Force -ErrorAction Stop
}
}
# Common assemblies used by Add-Type or assemblies with high JIT and no pdbs to crossgen
$commonAssembliesForAddType = @(
"Microsoft.CodeAnalysis.CSharp.dll"
"Microsoft.CodeAnalysis.dll"
"System.Linq.Expressions.dll"
"Microsoft.CSharp.dll"
"System.Runtime.Extensions.dll"
"System.Linq.dll"
"System.Collections.Concurrent.dll"
"System.Collections.dll"
"Newtonsoft.Json.dll"
"System.IO.FileSystem.dll"
"System.Diagnostics.Process.dll"
"System.Threading.Tasks.Parallel.dll"
"System.Security.AccessControl.dll"
"System.Text.Encoding.CodePages.dll"
"System.Private.Uri.dll"
"System.Threading.dll"
"System.Security.Principal.Windows.dll"
"System.Console.dll"
"Microsoft.Win32.Registry.dll"
"System.IO.Pipes.dll"
"System.Diagnostics.FileVersionInfo.dll"
"System.Collections.Specialized.dll"
)
# Common PowerShell libraries to crossgen
2016-08-03 09:19:39 +02:00
$psCoreAssemblyList = @(
"Microsoft.PowerShell.Commands.Utility.dll",
"Microsoft.PowerShell.Commands.Management.dll",
"Microsoft.PowerShell.Security.dll",
"Microsoft.PowerShell.CoreCLR.AssemblyLoadContext.dll",
"Microsoft.PowerShell.CoreCLR.Eventing.dll",
"Microsoft.PowerShell.ConsoleHost.dll",
"Microsoft.PowerShell.PSReadLine.dll",
"System.Management.Automation.dll"
)
2016-08-02 22:33:51 +02:00
# Add Windows specific libraries
if ($IsWindows) {
2016-08-03 09:19:39 +02:00
$psCoreAssemblyList += @(
"Microsoft.WSMan.Management.dll",
"Microsoft.WSMan.Runtime.dll",
"Microsoft.PowerShell.Commands.Diagnostics.dll",
"Microsoft.Management.Infrastructure.CimCmdlets.dll"
)
}
$fullAssemblyList = $commonAssembliesForAddType + $psCoreAssemblyList
foreach ($assemblyName in $fullAssemblyList) {
2016-08-02 22:33:51 +02:00
$assemblyPath = Join-Path $PublishPath $assemblyName
2016-08-03 09:19:39 +02:00
Generate-CrossGenAssembly -CrossgenPath $crossGenPath -AssemblyPath $assemblyPath
}
2016-08-02 22:33:51 +02:00
#
# With the latest dotnet.exe, the default load context is only able to load TPAs, and TPA
# only contains IL assembly names. In order to make the default load context able to load
# the NI PS assemblies, we need to replace the IL PS assemblies with the corresponding NI
# PS assemblies, but with the same IL assembly names.
#
Write-Verbose "PowerShell Ngen assemblies have been generated. Deploying ..." -Verbose
foreach ($assemblyName in $fullAssemblyList) {
2016-08-03 09:19:39 +02:00
# Remove the IL assembly and its symbols.
$assemblyPath = Join-Path $PublishPath $assemblyName
$symbolsPath = [System.IO.Path]::ChangeExtension($assemblyPath, ".pdb")
Remove-Item $assemblyPath -Force -ErrorAction Stop
# No symbols are available for Microsoft.CodeAnalysis.CSharp.dll, Microsoft.CodeAnalysis.dll,
# Microsoft.CodeAnalysis.VisualBasic.dll, and Microsoft.CSharp.dll.
if ($commonAssembliesForAddType -notcontains $assemblyName) {
Remove-Item $symbolsPath -Force -ErrorAction Stop
}
# Rename the corresponding ni.dll assembly to be the same as the IL assembly
$niAssemblyPath = [System.IO.Path]::ChangeExtension($assemblyPath, "ni.dll")
Rename-Item $niAssemblyPath $assemblyPath -Force -ErrorAction Stop
2016-08-02 22:33:51 +02:00
}
}
2017-01-17 22:00:52 +01:00
# Cleans the PowerShell repo - everything but the root folder
function Clear-PSRepo
{
[CmdletBinding()]
2017-01-17 22:00:52 +01:00
param()
Get-ChildItem $PSScriptRoot\* -Directory | ForEach-Object {
2017-01-16 22:31:14 +01:00
Write-Verbose "Cleaning $_ ..."
git clean -fdX $_
}
}
# Install PowerShell modules such as PackageManagement, PowerShellGet
function Restore-PSModule
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string[]]$Name,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]$Destination,
2016-11-19 02:51:29 +01:00
[string]$SourceLocation="https://powershell.myget.org/F/powershellmodule/api/v2/",
[string]$RequiredVersion
)
$needRegister = $true
$RepositoryName = "mygetpsmodule"
# Check if the PackageManagement works in the base-oS or PowerShellCore
Get-PackageProvider -Name NuGet -ForceBootstrap -Verbose:$VerbosePreference
2016-11-19 02:51:29 +01:00
Get-PackageProvider -Name PowerShellGet -Verbose:$VerbosePreference
# Get the existing registered PowerShellGet repositories
$psrepos = PowerShellGet\Get-PSRepository
foreach ($repo in $psrepos)
{
if(($repo.SourceLocation -eq $SourceLocation) -or ($repo.SourceLocation.TrimEnd("/") -eq $SourceLocation.TrimEnd("/")))
{
# found a registered repository that matches the source location
$needRegister = $false
$RepositoryName = $repo.Name
break
}
}
if($needRegister)
{
$regVar = PowerShellGet\Get-PSRepository -Name $RepositoryName -ErrorAction SilentlyContinue
if($regVar)
{
PowerShellGet\UnRegister-PSRepository -Name $RepositoryName
}
log "Registering PSRepository with name: $RepositoryName and sourcelocation: $SourceLocation"
PowerShellGet\Register-PSRepository -Name $RepositoryName -SourceLocation $SourceLocation -ErrorVariable ev -verbose
if($ev)
{
throw ("Failed to register repository '{0}'" -f $RepositoryName)
}
$regVar = PowerShellGet\Get-PSRepository -Name $RepositoryName
if(-not $regVar)
{
throw ("'{0}' is not registered" -f $RepositoryName)
}
}
log ("Name='{0}', Destination='{1}', Repository='{2}'" -f ($Name -join ','), $Destination, $RepositoryName)
Jameswtruher/travisdailybuild (#2958) * Stifle progress output in build.psm1 for some operations Modify test failure presentation to use platform available XML methods * Add timeout support for returning runtime parsing errors Some of the language/parser tests have been hanging in a non-reproducable manner which causes the CI system to invalidate the entire run. This change adds support for timeout which will fail a test if it runs to long, rather than invalidate the entire run. current behavior is still supported, and is not done in a new session: PS> get-runtimeerror -src '1/' At line:1 char:3 + 1/ + ~ You must provide a value expression following the '/' operator. + CategoryInfo : ParserError: (:) [], ParentContainsErrorRecordException + FullyQualifiedErrorId : ExpectedValueExpression Adding a timeout will do the operation in a async powershell session PS> get-runtimeerror -src '1/' -timeout 5 You must provide a value expression following the '/' operator. + CategoryInfo : ParserError: (:) [], ParentContainsErrorRecordException + FullyQualifiedErrorId : ExpectedValueExpression If the operation takes longer than the supplied timeout, a timeout error will be returned PS> get-runtimeerror -src 'start-sleep 6' -timeout 2 get-runtimeerror : Operation Timed Out ('start-sleep 6') At line:1 char:1 + get-runtimeerror -src 'start-sleep 6' -timeout 2 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : NotSpecified: (:) [Write-Error], WriteErrorException + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-RuntimeError * Modify native linux command tests to skip on Windows and pending on Mac * remove verbose and progress output from help tests * Be sure that Feature Counter tests only run on Windows Also, only call add-type in CounterTestHelperFunctions.ps1 if we're going to actually run the tests * do not run any get-computerinfo tests on non-windows systems * suppress progress output from PowerShell Get tests * remove -quiet from API and CRON Builds Travis watches output from the build to ensure that it hasn't hung we need to find a balance between too much output and not enough output. A run which has too much output is killed because it looks like an error loop A run which has too little output is killed because it looks like a hang * Remove commented line in Import-Counter.Tests.ps1 Remove extraneous extra line in PowerShellGet.Tests.ps1 * Change `-as "type"` to `-as [type]` in build.psm1 Alter timeout to 10 seconds to be improve chances of not timing out for runtime parser checks improve logic for counter tests to also skip for IoT * use the existing function of SkipCounterTests rather than duplicate the logic in import-counter.tests.ps1
2017-01-10 23:42:27 +01:00
# do not output progress
$ProgressPreference = "SilentlyContinue"
$Name | ForEach-Object {
$command = @{
Name=$_
Path = $Destination
Repository =$RepositoryName
}
if($RequiredVersion)
{
$command.Add("RequiredVersion", $RequiredVersion)
}
# pull down the module
log "running save-module $_"
PowerShellGet\Save-Module @command -Force
2017-01-16 22:31:14 +01:00
# Remove PSGetModuleInfo.xml file
Find-Module -Name $_ -Repository $RepositoryName -IncludeDependencies | ForEach-Object {
Remove-Item -Path $Destination\$($_.Name)\*\PSGetModuleInfo.xml -Force
}
}
# Clean up
if($needRegister)
{
2016-11-19 02:51:29 +01:00
$regVar = PowerShellGet\Get-PSRepository -Name $RepositoryName -ErrorAction SilentlyContinue
if($regVar)
{
log "Unregistering PSRepository with name: $RepositoryName"
PowerShellGet\UnRegister-PSRepository -Name $RepositoryName
}
}
}
$script:RESX_TEMPLATE = @'
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
{0}
</root>
2016-07-05 19:36:38 +02:00
'@