lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [08/11] lucenenet git commit: build\build.ps1: Updated script to automatically install the .NET Core 1.0.0-preview2-1-003177 SDK if it is not present and to check for the presence of git.exe before attempting to append the commit hash to the AssemblyInfo
Date Thu, 27 Apr 2017 01:32:53 GMT
build\build.ps1: Updated script to automatically install the .NET Core 1.0.0-preview2-1-003177
SDK if it is not present and to check for the presence of git.exe before attempting to append
the commit hash to the AssemblyInformationalVersion


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/ea10aded
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/ea10aded
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/ea10aded

Branch: refs/heads/master
Commit: ea10aded4a1499316a4ac4e113369723be474d57
Parents: bdb9601
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Thu Apr 27 07:13:46 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Thu Apr 27 08:25:36 2017 +0700

----------------------------------------------------------------------
 build/build.ps1          |  26 ++-
 build/dotnet-install.ps1 | 440 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 463 insertions(+), 3 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ea10aded/build/build.ps1
----------------------------------------------------------------------
diff --git a/build/build.ps1 b/build/build.ps1
index 75d86ef..7a28856 100644
--- a/build/build.ps1
+++ b/build/build.ps1
@@ -39,9 +39,24 @@ task Clean -description "This task cleans up the build directory" {
 
 task Init -description "This task makes sure the build environment is correctly setup" {
 	& where.exe dotnet.exe
+	$sdkVersion = ""
+
+	if ($LASTEXITCODE -eq 0) {
+		$sdkVersion = ((& dotnet.exe --version) | Out-String).Trim()
+	}
+	
+	Write-Host "Current SDK version: $sdkVersion" -ForegroundColor Yellow
+	if (!$sdkVersion.Equals("1.0.0-preview2-1-003177")) {
+		Write-Host "Require SDK version 1.0.0-preview2-1-003177, installing..." -ForegroundColor
Red
+		#Install the correct version of the .NET SDK for this build
+	    Invoke-Expression "$base_directory\build\dotnet-install.ps1 -Version 1.0.0-preview2-1-003177"
+	}
+
+	# Safety check - this should never happen
+	& where.exe dotnet.exe
 
 	if ($LASTEXITCODE -ne 0) {
-		throw "Could not find dotnet CLI in PATH. Please install the .NET Core 1.1 SDK."
+		throw "Could not find dotnet CLI in PATH. Please install the .NET Core 1.1 SDK version
1.0.0-preview2-1-003177."
 	}
 
 	#Update TeamCity or MyGet with packageVersion
@@ -205,8 +220,13 @@ function Get-Version() {
 function Prepare-For-Build([string[]]$projects) {
 	Backup-File $common_assembly_info 
 	
-	$gitCommit = ((git rev-parse --verify --short=10 head) | Out-String).Trim()
-	$pv = "$packageVersion commit:[$gitCommit]"
+	$pv = $packageVersion
+	#check for presense of Git
+	& where.exe git.exe
+	if ($LASTEXITCODE -eq 0) {
+		$gitCommit = ((git rev-parse --verify --short=10 head) | Out-String).Trim()
+		$pv = "$packageVersion commit:[$gitCommit]"
+	}
 
 	Generate-Assembly-Info `
 		-product $product_name `

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ea10aded/build/dotnet-install.ps1
----------------------------------------------------------------------
diff --git a/build/dotnet-install.ps1 b/build/dotnet-install.ps1
new file mode 100644
index 0000000..379954f
--- /dev/null
+++ b/build/dotnet-install.ps1
@@ -0,0 +1,440 @@
+#
+# Copyright (c) .NET Foundation and contributors. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for full license information.
+#
+
+<#
+.SYNOPSIS
+    Installs dotnet cli
+.DESCRIPTION
+    Installs dotnet cli. If dotnet installation already exists in the given directory
+    it will update it only if the requested version differs from the one already installed.
+.PARAMETER Channel
+    Default: preview
+    Channel is the way of reasoning about stability and quality of dotnet. This parameter
takes one of the values:
+    - future - Possibly unstable, frequently changing, may contain new finished and unfinished
features
+    - preview - Pre-release stable with known issues and feature gaps
+    - production - Most stable releases
+.PARAMETER Version
+    Default: latest
+    Represents a build version on specific channel. Possible values:
+    - 4-part version in a format A.B.C.D - represents specific version of build
+    - latest - most latest build on specific channel
+    - lkg - last known good version on specific channel
+    Note: LKG work is in progress. Once the work is finished, this will become new default
+.PARAMETER InstallDir
+    Default: %LocalAppData%\Microsoft\dotnet
+    Path to where to install dotnet. Note that binaries will be placed directly in a given
directory.
+.PARAMETER Architecture
+    Default: <auto> - this value represents currently running OS architecture
+    Architecture of dotnet binaries to be installed.
+    Possible values are: <auto>, x64 and x86
+.PARAMETER SharedRuntime
+    Default: false
+    Installs just the shared runtime bits, not the entire SDK
+.PARAMETER DebugSymbols
+    If set the installer will include symbols in the installation.
+.PARAMETER DryRun
+    If set it will not perform installation but instead display what command line to use
to consistently install
+    currently requested version of dotnet cli. In example if you specify version 'latest'
it will display a link
+    with specific version so that this command can be used deterministicly in a build script.
+    It also displays binaries location if you prefer to install or download it yourself.
+.PARAMETER NoPath
+    By default this script will set environment variable PATH for the current process to
the binaries folder inside installation folder.
+    If set it will display binaries location but not set any environment variable.
+.PARAMETER Verbose
+    Displays diagnostics information.
+.PARAMETER AzureFeed
+    Default: https://dotnetcli.azureedge.net/dotnet
+    This parameter should not be usually changed by user. It allows to change URL for the
Azure feed used by this installer.
+.PARAMETER ProxyAddress
+    If set, the installer will use the proxy when making web requests
+#>
+[cmdletbinding()]
+param(
+   [string]$Channel="rel-1.0.0",
+   [string]$Version="Latest",
+   [string]$InstallDir="<auto>",
+   [string]$Architecture="<auto>",
+   [switch]$SharedRuntime,
+   [switch]$DebugSymbols, # TODO: Switch does not work yet. Symbols zip is not being uploaded
yet.
+   [switch]$DryRun,
+   [switch]$NoPath,
+   [string]$AzureFeed="https://dotnetcli.azureedge.net/dotnet",
+   [string]$UncachedFeed="https://dotnetcli.blob.core.windows.net/dotnet",
+   [string]$ProxyAddress
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference="Stop"
+$ProgressPreference="SilentlyContinue"
+
+$BinFolderRelativePath=""
+
+# example path with regex: shared/1.0.0-beta-12345/somepath
+$VersionRegEx="/\d+\.\d+[^/]+/"
+$OverrideNonVersionedFiles=$true
+
+function Say($str) {
+    Write-Host "dotnet-install: $str"
+}
+
+function Say-Verbose($str) {
+    Write-Verbose "dotnet-install: $str"
+}
+
+function Say-Invocation($Invocation) {
+    $command = $Invocation.MyCommand;
+    $args = (($Invocation.BoundParameters.Keys | foreach { "-$_ `"$($Invocation.BoundParameters[$_])`""
}) -join " ")
+    Say-Verbose "$command $args"
+}
+
+function Get-Machine-Architecture() {
+    Say-Invocation $MyInvocation
+
+    # possible values: AMD64, IA64, x86
+    return $ENV:PROCESSOR_ARCHITECTURE
+}
+
+# TODO: Architecture and CLIArchitecture should be unified
+function Get-CLIArchitecture-From-Architecture([string]$Architecture) {
+    Say-Invocation $MyInvocation
+
+    switch ($Architecture.ToLower()) {
+        { $_ -eq "<auto>" } { return Get-CLIArchitecture-From-Architecture $(Get-Machine-Architecture)
}
+        { ($_ -eq "amd64") -or ($_ -eq "x64") } { return "x64" }
+        { $_ -eq "x86" } { return "x86" }
+        default { throw "Architecture not supported. If you think this is a bug, please report
it at https://github.com/dotnet/cli/issues" }
+    }
+}
+
+function Get-Version-Info-From-Version-Text([string]$VersionText) {
+    Say-Invocation $MyInvocation
+
+    $Data = @($VersionText.Split([char[]]@(), [StringSplitOptions]::RemoveEmptyEntries));
+
+    $VersionInfo = @{}
+    $VersionInfo.CommitHash = $Data[0].Trim()
+    $VersionInfo.Version = $Data[1].Trim()
+    return $VersionInfo
+}
+
+function Load-Assembly([string] $Assembly) {
+    try {
+        Add-Type -Assembly $Assembly | Out-Null
+    }
+    catch {
+        # On Nano Server, Powershell Core Edition is used.  Add-Type is unable to resolve
base class assemblies because they are not GAC'd.
+        # Loading the base class assemblies is not unnecessary as the types will automatically
get resolved.
+    }
+}
+
+function GetHTTPResponse([Uri] $Uri)
+{
+    $HttpClient = $null
+
+    try {
+        # HttpClient is used vs Invoke-WebRequest in order to support Nano Server which doesn't
support the Invoke-WebRequest cmdlet.
+        Load-Assembly -Assembly System.Net.Http
+        if($ProxyAddress){
+            $HttpClientHandler = New-Object System.Net.Http.HttpClientHandler
+            $HttpClientHandler.Proxy =  New-Object System.Net.WebProxy -Property @{Address=$ProxyAddress}
+            $HttpClient = New-Object System.Net.Http.HttpClient -ArgumentList $HttpClientHandler
+        } 
+        else {
+            $HttpClient = New-Object System.Net.Http.HttpClient
+        }
+        # Default timeout for HttpClient is 100s.  For a 50 MB download this assumes 500
KB/s average, any less will time out
+        # 5 minutes allows it to work over much slower connections.
+        $HttpClient.Timeout = New-TimeSpan -Minutes 5 
+        $Response = $HttpClient.GetAsync($Uri).Result
+        if (($Response -eq $null) -or (-not ($Response.IsSuccessStatusCode)))
+        {
+            $ErrorMsg = "Failed to download $Uri."
+            if ($Response -ne $null)
+            {
+                $ErrorMsg += "  $Response"
+            }
+
+            throw $ErrorMsg
+        }
+
+        return $Response
+    }
+    finally {
+        if ($HttpClient -ne $null) {
+            $HttpClient.Dispose()
+        }
+    }
+}
+
+
+function Get-Latest-Version-Info([string]$AzureFeed, [string]$AzureChannel, [string]$CLIArchitecture)
{
+    Say-Invocation $MyInvocation
+
+    $VersionFileUrl = $null
+    if ($SharedRuntime) {
+        $VersionFileUrl = "$UncachedFeed/$AzureChannel/dnvm/latest.sharedfx.win.$CLIArchitecture.version"
+    }
+    else {
+        $VersionFileUrl = "$UncachedFeed/Sdk/$AzureChannel/latest.version"
+    }
+    
+    $Response = GetHTTPResponse -Uri $VersionFileUrl
+    $StringContent = $Response.Content.ReadAsStringAsync().Result
+
+    switch ($Response.Content.Headers.ContentType) {
+        { ($_ -eq "application/octet-stream") } { $VersionText = [Text.Encoding]::UTF8.GetString($StringContent)
}
+        { ($_ -eq "text/plain") } { $VersionText = $StringContent }
+        default { throw "``$Response.Content.Headers.ContentType`` is an unknown .version
file content type." }
+    }
+
+    $VersionInfo = Get-Version-Info-From-Version-Text $VersionText
+
+    return $VersionInfo
+}
+
+# TODO: AzureChannel and Channel should be unified
+function Get-Azure-Channel-From-Channel([string]$Channel) {
+    Say-Invocation $MyInvocation
+
+    # For compatibility with build scripts accept also directly Azure channels names
+    switch ($Channel.ToLower()) {
+        { ($_ -eq "future") -or ($_ -eq "dev") } { return "dev" }
+        { $_ -eq "production" } { throw "Production channel does not exist yet" }
+        default { return $_ }
+    }
+}
+
+function Get-Specific-Version-From-Version([string]$AzureFeed, [string]$AzureChannel, [string]$CLIArchitecture,
[string]$Version) {
+    Say-Invocation $MyInvocation
+
+    switch ($Version.ToLower()) {
+        { $_ -eq "latest" } {
+            $LatestVersionInfo = Get-Latest-Version-Info -AzureFeed $AzureFeed -AzureChannel
$AzureChannel -CLIArchitecture $CLIArchitecture
+            return $LatestVersionInfo.Version
+        }
+        { $_ -eq "lkg" } { throw "``-Version LKG`` not supported yet." }
+        default { return $Version }
+    }
+}
+
+function Get-Download-Links([string]$AzureFeed, [string]$AzureChannel, [string]$SpecificVersion,
[string]$CLIArchitecture) {
+    Say-Invocation $MyInvocation
+    
+    $ret = @()
+    
+    if ($SharedRuntime) {
+        $PayloadURL = "$AzureFeed/$AzureChannel/Binaries/$SpecificVersion/dotnet-win-$CLIArchitecture.$SpecificVersion.zip"
+    }
+    else {
+        $PayloadURL = "$AzureFeed/Sdk/$SpecificVersion/dotnet-dev-win-$CLIArchitecture.$SpecificVersion.zip"
+    }
+
+    Say-Verbose "Constructed payload URL: $PayloadURL"
+    $ret += $PayloadURL
+
+    return $ret
+}
+
+function Get-User-Share-Path() {
+    Say-Invocation $MyInvocation
+
+    $InstallRoot = $env:DOTNET_INSTALL_DIR
+    if (!$InstallRoot) {
+        $InstallRoot = "$env:LocalAppData\Microsoft\dotnet"
+    }
+    return $InstallRoot
+}
+
+function Resolve-Installation-Path([string]$InstallDir) {
+    Say-Invocation $MyInvocation
+
+    if ($InstallDir -eq "<auto>") {
+        return Get-User-Share-Path
+    }
+    return $InstallDir
+}
+
+function Get-Version-Info-From-Version-File([string]$InstallRoot, [string]$RelativePathToVersionFile)
{
+    Say-Invocation $MyInvocation
+
+    $VersionFile = Join-Path -Path $InstallRoot -ChildPath $RelativePathToVersionFile
+    Say-Verbose "Local version file: $VersionFile"
+    
+    if (Test-Path $VersionFile) {
+        $VersionText = cat $VersionFile
+        Say-Verbose "Local version file text: $VersionText"
+        return Get-Version-Info-From-Version-Text $VersionText
+    }
+
+    Say-Verbose "Local version file not found."
+
+    return $null
+}
+
+function Is-Dotnet-Package-Installed([string]$InstallRoot, [string]$RelativePathToPackage,
[string]$SpecificVersion) {
+    Say-Invocation $MyInvocation
+    
+    $DotnetPackagePath = Join-Path -Path $InstallRoot -ChildPath $RelativePathToPackage |
Join-Path -ChildPath $SpecificVersion
+    Say-Verbose "Is-Dotnet-Package-Installed: Path to a package: $DotnetPackagePath"
+    return Test-Path $DotnetPackagePath -PathType Container
+}
+
+function Get-Absolute-Path([string]$RelativeOrAbsolutePath) {
+    # Too much spam
+    # Say-Invocation $MyInvocation
+
+    return $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($RelativeOrAbsolutePath)
+}
+
+function Get-Path-Prefix-With-Version($path) {
+    $match = [regex]::match($path, $VersionRegEx)
+    if ($match.Success) {
+        return $entry.FullName.Substring(0, $match.Index + $match.Length)
+    }
+    
+    return $null
+}
+
+function Get-List-Of-Directories-And-Versions-To-Unpack-From-Dotnet-Package([System.IO.Compression.ZipArchive]$Zip,
[string]$OutPath) {
+    Say-Invocation $MyInvocation
+    
+    $ret = @()
+    foreach ($entry in $Zip.Entries) {
+        $dir = Get-Path-Prefix-With-Version $entry.FullName
+        if ($dir -ne $null) {
+            $path = Get-Absolute-Path $(Join-Path -Path $OutPath -ChildPath $dir)
+            if (-Not (Test-Path $path -PathType Container)) {
+                $ret += $dir
+            }
+        }
+    }
+    
+    $ret = $ret | Sort-Object | Get-Unique
+    
+    $values = ($ret | foreach { "$_" }) -join ";"
+    Say-Verbose "Directories to unpack: $values"
+    
+    return $ret
+}
+
+# Example zip content and extraction algorithm:
+# Rule: files if extracted are always being extracted to the same relative path locally
+# .\
+#       a.exe   # file does not exist locally, extract
+#       b.dll   # file exists locally, override only if $OverrideFiles set
+#       aaa\    # same rules as for files
+#           ...
+#       abc\1.0.0\  # directory contains version and exists locally
+#           ...     # do not extract content under versioned part
+#       abc\asd\    # same rules as for files
+#            ...
+#       def\ghi\1.0.1\  # directory contains version and does not exist locally
+#           ...         # extract content
+function Extract-Dotnet-Package([string]$ZipPath, [string]$OutPath) {
+    Say-Invocation $MyInvocation
+
+    Load-Assembly -Assembly System.IO.Compression.FileSystem
+    Set-Variable -Name Zip
+    try {
+        $Zip = [System.IO.Compression.ZipFile]::OpenRead($ZipPath)
+        
+        $DirectoriesToUnpack = Get-List-Of-Directories-And-Versions-To-Unpack-From-Dotnet-Package
-Zip $Zip -OutPath $OutPath
+        
+        foreach ($entry in $Zip.Entries) {
+            $PathWithVersion = Get-Path-Prefix-With-Version $entry.FullName
+            if (($PathWithVersion -eq $null) -Or ($DirectoriesToUnpack -contains $PathWithVersion))
{
+                $DestinationPath = Get-Absolute-Path $(Join-Path -Path $OutPath -ChildPath
$entry.FullName)
+                $DestinationDir = Split-Path -Parent $DestinationPath
+                $OverrideFiles=$OverrideNonVersionedFiles -Or (-Not (Test-Path $DestinationPath))
+                if ((-Not $DestinationPath.EndsWith("\")) -And $OverrideFiles) {
+                    New-Item -ItemType Directory -Force -Path $DestinationDir | Out-Null
+                    [System.IO.Compression.ZipFileExtensions]::ExtractToFile($entry, $DestinationPath,
$OverrideNonVersionedFiles)
+                }
+            }
+        }
+    }
+    finally {
+        if ($Zip -ne $null) {
+            $Zip.Dispose()
+        }
+    }
+}
+
+function DownloadFile([Uri]$Uri, [string]$OutPath) {
+    $Stream = $null
+
+    try {
+        $Response = GetHTTPResponse -Uri $Uri
+        $Stream = $Response.Content.ReadAsStreamAsync().Result
+        $File = [System.IO.File]::Create($OutPath)
+        $Stream.CopyTo($File)
+        $File.Close()
+    }
+    finally {
+        if ($Stream -ne $null) {
+            $Stream.Dispose()
+        }
+    }
+}
+
+function Prepend-Sdk-InstallRoot-To-Path([string]$InstallRoot, [string]$BinFolderRelativePath)
{
+    $BinPath = Get-Absolute-Path $(Join-Path -Path $InstallRoot -ChildPath $BinFolderRelativePath)
+    if (-Not $NoPath) {
+        Say "Adding to current process PATH: `"$BinPath`". Note: This change will not be
visible if PowerShell was run as a child process."
+        $env:path = "$BinPath;" + $env:path
+    }
+    else {
+        Say "Binaries of dotnet can be found in $BinPath"
+    }
+}
+
+$AzureChannel = Get-Azure-Channel-From-Channel -Channel $Channel
+$CLIArchitecture = Get-CLIArchitecture-From-Architecture $Architecture
+$SpecificVersion = Get-Specific-Version-From-Version -AzureFeed $AzureFeed -AzureChannel
$AzureChannel -CLIArchitecture $CLIArchitecture -Version $Version
+$DownloadLinks = Get-Download-Links -AzureFeed $AzureFeed -AzureChannel $AzureChannel -SpecificVersion
$SpecificVersion -CLIArchitecture $CLIArchitecture
+
+if ($DryRun) {
+    Say "Payload URLs:"
+    foreach ($DownloadLink in $DownloadLinks) {
+        Say "- $DownloadLink"
+    }
+    Say "Repeatable invocation: .\$($MyInvocation.MyCommand) -Version $SpecificVersion -Channel
$Channel -Architecture $CLIArchitecture -InstallDir $InstallDir"
+    exit 0
+}
+
+$InstallRoot = Resolve-Installation-Path $InstallDir
+Say-Verbose "InstallRoot: $InstallRoot"
+
+$IsSdkInstalled = Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage
"sdk" -SpecificVersion $SpecificVersion
+Say-Verbose ".NET SDK installed? $IsSdkInstalled"
+if ($IsSdkInstalled) {
+    Say ".NET SDK version $SpecificVersion is already installed."
+    Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot -BinFolderRelativePath $BinFolderRelativePath
+    exit 0
+}
+
+New-Item -ItemType Directory -Force -Path $InstallRoot | Out-Null
+
+$free = Get-CimInstance -Class win32_logicaldisk | where Deviceid -eq "$((Get-Item $InstallRoot).PSDrive.Name):"
+if ($free.Freespace / 1MB -le 250 ) {
+    Say "there is not enough disk space on drive c:"
+    exit 0
+}
+
+foreach ($DownloadLink in $DownloadLinks) {
+    $ZipPath = [System.IO.Path]::GetTempFileName()
+    Say "Downloading $DownloadLink"
+    DownloadFile -Uri $DownloadLink -OutPath $ZipPath
+
+    Say "Extracting zip from $DownloadLink"
+    Extract-Dotnet-Package -ZipPath $ZipPath -OutPath $InstallRoot
+
+    Remove-Item $ZipPath
+}
+
+Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot -BinFolderRelativePath $BinFolderRelativePath
+
+Say "Installation finished"
+exit 0
\ No newline at end of file


Mime
View raw message