Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission	Action
PsGet.psm1	80.42 KB	-rw-rw-rw-

Code Editor : PsGet.psm1

<#
.SYNOPSIS
    PowerShell module installation stuff.
    URL: https://github.com/psget/psget
    Based on http://poshcode.org/1875 Install-Module by Joel Bennett
#>
#requires -Version 2.0

#region Setup

Write-Debug 'Set up the global scope config variables.'
if ([Environment]::GetFolderPath('MyDocuments')) {
    $global:UserModuleBasePath = Join-Path -Path ([Environment]::GetFolderPath('MyDocuments')) -ChildPath 'WindowsPowerShell\Modules'
}
else {
    # Support scenarios where PSGet is running without a MyDocuments special folder (e.g. executing within a DSC resource)
    $global:UserModuleBasePath = Join-Path -Path $env:ProgramFiles -ChildPath 'WindowsPowerShell\Modules'
}

# NOTE: Path changed to align with current MS conventions
$global:CommonGlobalModuleBasePath = Join-Path -Path $env:ProgramFiles -ChildPath 'WindowsPowerShell\Modules'

if (-not (Test-Path -Path:variable:global:PsGetDirectoryUrl)) {
    $global:PsGetDirectoryUrl = 'https://github.com/psget/psget/raw/master/Directory.xml'
}
# NOTE: $global:PsGetDestinationModulePath is used by Install-Module as configuration if set by user.

Write-Debug 'Set up needed constants.'
Set-Variable -Name PSGET_ZIP -Value 'ZIP' -Option Constant -Scope Script
Set-Variable -Name PSGET_PSM1 -Value 'PSM1' -Option Constant -Scope Script
Set-Variable -Name PSGET_PSD1 -Value 'PSD1' -Option Constant -Scope Script

#endregion

#region Exported Cmdlets

<#
    .SYNOPSIS
        Installs PowerShell modules from a variety of sources including: Nuget, PsGet module directory, local directory, zipped folder and web URL.

.DESCRIPTION
        Supports installing modules for the current user or all users (if elevated).

.PARAMETER Module
        Name of the module to install.

.PARAMETER ModuleUrl
        URL to the module to install; Can be direct link to PSM1 file or ZIP file. Can be a shortened link.

.PARAMETER ModulePath
        Local path to the module to install.

.PARAMETER ModuleName
       In context with -ModuleUrl or -ModulePath it is not always possible to interfere the right ModuleName, eg. the filename is unknown or the zip archive contains multiple modules.

.PARAMETER Type
        When ModuleUrl or ModulePath specified, allows specifying type of the package. Can be ZIP or PSM1.

.PARAMETER NuGetPackageId
        NuGet package name containing the module to install.

.PARAMETER PackageVersion
        Allows a specific version of the specified NuGet package to used, if not specified then the latest stable version will be used.

.PARAMETER NugetSource
        URL to the NuGet feed containing the package.

.PARAMETER PreRelease
        If PackageVersion is not specified, then this switch allows the latest prerelease package to be used.

.PARAMETER PreReleaseTag
        If PackageVersion is not specified, then this parameter allows the latest version of a particular prerelease tag to be used

.PARAMETER Destination
        When specified the module will be installed below this path. Defaults to '$global:PsGetDestinationModulePath' if defined.

.PARAMETER ModuleHash
        When ModuleHash is specified the chosen module will only be installed if its contents match the provided hash.

.PARAMETER Global
        If set, attempts to install the module to the all users location in C:\Program Files\Common Files\Modules...

NOTE: If the -Destination directory is specified, then -Global will only have an effect in combination with '-PersistEnvironment'. This is also the case if '$global:PsGetDestinationModulePath' is defined.

.PARAMETER DoNotImport
        Indicates that command should not import module after installation

.PARAMETER AddToProfile
        Adds Import-Module statement for installed module to the profile.ps1

.PARAMETER Update
        Forces module to be updated

.PARAMETER DirectoryUrl
        URL to central directory. By default it uses the value in the $global:PsGetDirectoryUrl variable

.PARAMETER PersistEnvironment
        If this switch is specified, the installation destination path will be added to either the User's PSModulePath environment variable or Machine's PSModulePath environment variable (if -Global specified)

.PARAMETER InstallWithModuleName
        Allows to specify the name of the module and override the ModuleName normally used.
        NOTE: This parameter allows to install a module from the PsGet-Directory more than once and PsGet does not remember that this module is installed with a different name.

.PARAMETER DoNotPostInstall
        If defined, the PostInstallHook is not executed.

.PARAMETER Force
        OBSOLETE
        Alternative name for 'Update'.

.PARAMETER Startup
        OBSOLETE
        Alternative name for 'AddToProfile'.

.LINK
        http://psget.net

.EXAMPLE
        # Install-Module PsConfig -DoNotImport

Description
        -----------
        Installs the module without importing it to the current session

.EXAMPLE
        # Install-Module PoshHg -AddToProfile

Description
        -----------
        Installs the module and then adds impoer of the given module to your profile.ps1 file

.EXAMPLE
        # Install-Module PsUrl

Description
        -----------
        This command will query module information from central registry and install required stuff.

.EXAMPLE
        # Install-Module -ModulePath .\Authenticode.psm1 -Global

Description
        -----------
        Installs the Authenticode module to the System32\WindowsPowerShell\v1.0\Modules for all users to use.

.EXAMPLE
        # Install-Module -ModuleUrl https://github.com/chaliy/psurl/raw/master/PsUrl/PsUrl.psm1

Description
        -----------
        Installs the PsUrl module to the users modules folder

.EXAMPLE
        # Install-Module -ModuleUrl http://bit.ly/e1X4BO -ModuleName "PsUrl"

Description
        -----------
        Installs the PsUrl module with name specified, because command will not be able to guess it

.EXAMPLE
        # Install-Module -ModuleUrl https://github.com/psget/psget/raw/master/TestModules/HelloWorld.zip

Description
        -----------
        Downloads HelloWorld module (module can have more than one file) and installs it

.EXAMPLE
        # Install-Module -NugetPackageId SomePackage

Description
        -----------
        Downloads the latest stable version of the 'SomePackage' module from the NuGet Gallery

.EXAMPLE
        # Install-Module -NugetPackageId SomePackage -PackageVersion 1.0.2-beta

Description
        -----------
        Downloads the specified version of the 'SomePackage' module from the NuGet Gallery

.EXAMPLE
        # Install-Module -NugetPackageId SomePackage -PreRelease

Description
        -----------
        Downloads the latest pre-release version of the 'SomePackage' module from the NuGet Gallery

.EXAMPLE
        # Install-Module -NugetPackageId SomePackage -PreReleaseTag beta -NugetSource http://myget.org/F/myfeed

Description
        -----------
        Downloads the latest 'beta' pre-release version of the 'SomePackage' module from a custom NuGet feed
#>
function Install-Module {
    [CmdletBinding()]
    param (
        [Parameter(Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, Mandatory=$true, ParameterSetName='CentralDirectory')]
        [String] $Module,

[Parameter(ValueFromPipelineByPropertyName=$true, Mandatory=$true, ParameterSetName='Web')]
        [String] $ModuleUrl,

[Parameter(ValueFromPipelineByPropertyName=$true, Mandatory=$true, ParameterSetName='Local')]
        [String] $ModulePath,

[Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='Web')]
        [Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='Local')]
        [String] $ModuleName,

[Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='Web')]
        [Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='Local')]
        [ValidateSet('ZIP', 'PSM1', 'PSD1', '')] # $script:PSGET_ZIP, $script:PSGET_PSM1 or $script:PSGET_PSD1
        [String] $Type,

[Parameter(ValueFromPipelineByPropertyName=$true, Mandatory=$true, ParameterSetName='NuGet')]
        [ValidatePattern('^\w+([_.-]\w+)*$')] # regex from NuGet.PackageIdValidator._idRegex
        [ValidateLength(1,100)] # maximum length from NuGet.PackageIdValidator.MaxPackageIdLength
        [String] $NuGetPackageId,

[Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='NuGet')]
        [String] $PackageVersion,

[Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='NuGet')]
        [String] $NugetSource = 'https://nuget.org/api/v2/',

[Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='NuGet')]
        [Switch] $PreRelease,

[Parameter(ValueFromPipelineByPropertyName=$true, ParameterSetName='NuGet')]
        [String] $PreReleaseTag,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $Destination = $global:PsGetDestinationModulePath,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $ModuleHash,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $Global,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $DoNotImport,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $AddToProfile,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $Update,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $DirectoryUrl = $global:PsGetDirectoryUrl,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $PersistEnvironment,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $InstallWithModuleName,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $DoNotPostInstall,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $PostInstallHook,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $Force,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $Startup
    )
    process {

if ($Force) {
            Write-Verbose 'Force parameter is considered obsolete. Please use Update instead.'
            $Update = $true
        }

if ($Startup) {
            Write-Verbose 'Startup parameter is considered obsolete. Please use AddToProfile instead.'
            $AddToProfile = $true
        }

if (-not $Destination) {
            $Destination = if ($Global) { $global:CommonGlobalModuleBasePath } else { $global:UserModuleBasePath }

#Because we are using the default location, always ensure it is persisted
            $PersistEnvironment = $true
        }

if (-not $Destination) {
            throw 'The destination path was not added to the PSModulePath environment variable, ensure you have the rights to modify environment variables'
        }

$Destination = ConvertTo-CanonicalPath -Path $Destination

Write-Debug "Execute installation for '$($PSCmdlet.ParameterSetName)' type."

switch($PSCmdlet.ParameterSetName) {
            CentralDirectory {
                Install-ModuleFromDirectory -Module:$Module -Destination:$Destination -ModuleHash:$ModuleHash -Global:$Global -PersistEnvironment:$PersistEnvironment -DoNotImport:$DoNotImport -AddToProfile:$AddToProfile -Update:$Update -DirectoryUrl:$DirectoryUrl -InstallWithModuleName:$InstallWithModuleName -DoNotPostInstall:$DoNotPostInstall -PostInstallHook:$PostInstallHook
            }
            Web {
                Install-ModuleFromWeb -ModuleUrl:$ModuleUrl -ModuleName:$ModuleName -Type:$Type -Destination:$Destination -ModuleHash:$ModuleHash -Global:$Global -PersistEnvironment:$PersistEnvironment -DoNotImport:$DoNotImport -AddToProfile:$AddToProfile -Update:$Update -InstallWithModuleName:$InstallWithModuleName -DoNotPostInstall:$DoNotPostInstall -PostInstallHook:$PostInstallHook
            }
            Local {
                Install-ModuleFromLocal -ModulePath:$ModulePath -ModuleName:$ModuleName -Type:$Type -Destination:$Destination -ModuleHash:$ModuleHash -Global:$Global -PersistEnvironment:$PersistEnvironment -DoNotImport:$DoNotImport -AddToProfile:$AddToProfile -Update:$Update -InstallWithModuleName:$InstallWithModuleName -DoNotPostInstall:$DoNotPostInstall -PostInstallHook:$PostInstallHook
            }
            NuGet {
                Install-ModuleFromNuGet -NuGetPackageId:$NuGetPackageId -PackageVersion:$PackageVersion -NugetSource:$NugetSource -PreRelease:$PreRelease -PreReleaseTag:$PreReleaseTag -Destination:$Destination -ModuleHash:$ModuleHash -Global:$Global -PersistEnvironment:$PersistEnvironment -DoNotImport:$DoNotImport -AddToProfile:$AddToProfile -Update:$Update -InstallWithModuleName:$InstallWithModuleName -DoNotPostInstall:$DoNotPostInstall -PostInstallHook:$PostInstallHook
            }
            default {
                throw "Unknown ParameterSetName '$($PSCmdlet.ParameterSetName)'"
            }
        }
    }
}

<#
    .SYNOPSIS
        Updates a module.

.DESCRIPTION
        Supports updating modules for the current user or all users (if elevated).

.PARAMETER Module
        Name of the module to update.

.PARAMETER All
        If -All is defined. all to PsGet known modules will be updated.

.PARAMETER Destination
        When specified the module will be updated below this path.

.PARAMETER ModuleHash
        When ModuleHash is specified the chosen module will only be installed if its contents match the provided hash.

.PARAMETER Global
        If set, attempts to install the module to the all users location in Windows\System32...

.PARAMETER DoNotImport
        Indicates that command should not import module after installation.

.PARAMETER AddToProfile
        Adds installed module to the profile.ps1.

.PARAMETER Update
        Forces module to be updated.

.PARAMETER DirectoryUrl
        URL to central directory. By default it uses the value in the $PsGetDirectoryUrl global variable.

.PARAMETER DoNotPostInstall
        If defined, the PostInstallHook is not executed.

.PARAMETER PostInstallHook
        Defines the name of a script inside the installed module folder which should be executed after installation.
        Will not be check in combination with -All switch.
        Default: 'Install.ps1'

.LINK
        http://psget.net

.LINK
        Install-Module

.EXAMPLE
        # Update-Module PsUrl

Description
        -----------
        Updates the module
#>
function Update-Module {
    [CmdletBinding()]
    param (
        [Parameter(Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, Mandatory=$true)]
        [String] $Module,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $All,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $Destination = $global:PsGetDestinationModulePath,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $ModuleHash,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $Global,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $DoNotImport,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $AddToProfile,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $DirectoryUrl = $global:PsGetDirectoryUrl,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [Switch] $DoNotPostInstall,

[Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $PostInstallHook
    )
    process {
        if ($All) {
            Install-Module -Module PSGet -Force -DoNotImport

Get-PsGetModuleInfo -ModuleName '*' | Where-Object {
                    if ($_.Id -ne 'PSGet') {
                        Get-Module -Name:($_.ModuleName) -ListAvailable
                    }
                } | Install-Module -Update

Import-Module -Name PSGet -Force -DoNotPostInstall:$DoNotPostInstall

}
        else {
            Install-Module -Module:$Module -Destination:$Destination -ModuleHash:$ModuleHash -Global:$Global -DoNotImport:$DoNotImport -AddToProfile:$AddToProfile -DirectoryUrl:$DirectoryUrl -Update -DoNotPostInstall:$DoNotPostInstall -PostInstallHook:$PostInstallHook
        }
    }
}

<#
    .SYNOPSIS
        Retrieve information about module from central directory

.DESCRIPTION
        Command will query central directory to get information about module specified.

.PARAMETER ModuleName
        Name of module to look for in directory. Supports wildcards.

.PARAMETER DirectoryUrl
        URL to central directory. By default it uses the value in the $PsGetDirectoryUrl global variable.

.LINK
        http://psget.net

.EXAMPLE
        Get-PsGetModuleInfo PoshCo*

Description
        -----------
        Retrieves information about all registered modules that start with PoshCo.
#>
function Get-PsGetModuleInfo {
    [CmdletBinding()]
    param (
        [Parameter(Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, Mandatory=$true)]
        [String] $ModuleName,
        [Parameter(ValueFromPipelineByPropertyName=$true)]
        [String] $DirectoryUrl = $global:PsGetDirectoryUrl
    )
    begin {
        $client = (new-object Net.WebClient)
        $client.Proxy.Credentials = [System.Net.CredentialCache]::DefaultNetworkCredentials

$PsGetDataPath = Join-Path -Path $Env:APPDATA -ChildPath psget
        $DirectoryCachePath = Join-Path -Path $PsGetDataPath -ChildPath directorycache.clixml
        $DirectoryCache = @()
        $CacheEntry = $null
        if (Test-Path -Path $DirectoryCachePath) {
            $DirectoryCache = Import-Clixml -Path $DirectoryCachePath
            $CacheEntry = $DirectoryCache | Where-Object { $_.Url -eq $DirectoryUrl } | Select-Object -First 1
        }
        if (-not $CacheEntry) {
            $CacheEntry = @{
                Url = $DirectoryUrl
                File = '{0}.xml' -f [Guid]::NewGuid().Tostring()
                ETag = $null
            }
            $DirectoryCache += @($CacheEntry)
        }
        $CacheEntryFilePath = Join-Path -Path $PsGetDataPath -ChildPath $CacheEntry.File
        if ($CacheEntry -and $CacheEntry.ETag -and (Test-Path -Path $CacheEntryFilePath)) {
            if ((Get-Item -Path $CacheEntryFilePath).LastWriteTime.AddDays(1) -gt (Get-Date)) {
                # use cached directory if it is less than 24 hours old
                $client.Headers.Add('If-None-Match', $CacheEntry.ETag)
            }
        }

try {
            Write-Verbose "Downloading modules repository from $DirectoryUrl"
            $stream = $client.OpenRead($DirectoryUrl)
            $repoXmlTemp = New-Object -TypeName System.Xml.XmlDocument
            $repoXmlTemp.Load($stream)
            $StatusCode = 200
        }
        catch [System.Net.WebException] {
            $Response = $_.Exception.Response
            if ($Response) { $StatusCode = [int]$Response.StatusCode }
        }

if ($StatusCode -eq 200) {
            $repoXml = [xml]$repoXmlTemp

$CacheEntry.ETag = $client.ResponseHeaders['ETag']
            if (-not (Test-Path -Path $PsGetDataPath)) {
                New-Item -Path $PsGetDataPath -ItemType Container | Out-Null
            }
            $repoXml.Save($CacheEntryFilePath)
            Export-Clixml -InputObject $DirectoryCache -Path $DirectoryCachePath
        }
        elseif (Test-Path -Path $CacheEntryFilePath) {
            if ($StatusCode -ne 304) {
                Write-Warning "Could not retrieve modules repository from '$DirectoryUrl'. Status code: $StatusCode"
            }
            Write-Verbose 'Using cached copy of modules repository'
            $repoXml = [xml](Get-Content -Path $CacheEntryFilePath)
        }
        else {
            throw "Could not retrieve modules repository from '$DirectoryUrl'. Status code: $StatusCode"
        }

$nss = @{ a = 'http://www.w3.org/2005/Atom';
                  pg = 'urn:psget:v1.0' }

$feed = $repoXml.feed
        $title = $feed.title.innertext
        Write-Verbose "Processing $title feed..."
    }
    process {
        # Very naive, ignoring namespaces and so on.
        $feed.entry | Where-Object { $_.id -like $ModuleName } |
            ForEach-Object {
                $Type = ''
                switch -regex ($_.content.type) {
                    'application/zip' { $Type = $PSGET_ZIP  }
                    default { $Type = $PSGET_PSM1  }
                }

$Verb = if ($_.properties.Verb -imatch 'POST') { 'POST' } else { 'GET' }

New-Object PSObject -Property @{
                    Title = $_.title.innertext
                    Description = $_.summary.'#text'
                    Updated = [DateTime]$_.updated
                    Author= $_.author.name
                    Id = $_.id
                    ModuleName = if ($_.properties.ModuleName) { $_.properties.ModuleName } else { $_.id }
                    Type = $Type
                    DownloadUrl = $_.content.src
                    Verb = $Verb
                    #This was changed from using the  $_.properties.ProjectUrl because the value for ModuleUrl needs to be the full path to the module file
                    #This change was required to get the tests to pass
                    ModuleUrl = $_.content.src
                    NoPostInstallHook = if ($_.properties.NoPostInstallHook -eq 'true') { $true } else { $false }
                    PostInstallHook = $_.properties.PostInstallHook
                    PostUpdateHook = $_.properties.PostUpdateHook
                } |
                    Select-Object Title, ModuleName, Id, Description, Updated, Type, Verb, ModuleUrl, DownloadUrl, NoPostInstallHook, PostInstallHook, PostUpdateHook
            }
    }
}

<#
    .SYNOPSIS
        Calculate the hash value of a module.

.DESCRIPTION
        Calculate the hash value of the specified module directory for usage with the 'ModuleHash' parameter for validation.

.PARAMETER Path
        Path to the module directory

.EXAMPLE
        Get-PsGetModuleHash $global:UserModuleBasePath\PsGet

Description
        -----------
        Returns the hash value usable with the 'ModuleHash' parameter of 'Install-Module'

.LINK
        Install-Module

.LINK
        http://psget.net
#>
function Get-PsGetModuleHash {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [Alias('ModuleBase')]
        [String] $Path
    )
    process {
        Get-FolderHash -Path (Resolve-Path -Path $Path).Path
    }
}

#endregion

#region Sub-Cmdlets

<#
    .SYNOPSIS
        Install a module from the defined PsGet directory.

.PARAMETER Module
        Name of the module to install from PsGet directory.

.PARAMETER Destination
        When specified the module will be installed below this path. Defaults to '$global:PsGetDestinationModulePath' if defined.

.PARAMETER ModuleHash
        When ModuleHash is specified the chosen module will only be installed if its contents match the provided hash.

.PARAMETER Global
        If set, attempts to install the module to the all users location in C:\Program Files\Common Files\Modules...

.PARAMETER DoNotImport
        Indicates that command should not import module after installation

.PARAMETER AddToProfile
        Adds Import-Module statement for installed module to the profile.ps1

.PARAMETER Update
        Forces module to be updated

.PARAMETER DirectoryUrl
        URL to central directory. By default it uses the value in the $global:PsGetDirectoryUrl variable

.PARAMETER DoNotPostInstall
        If defined, the PostInstallHook is not executed.

.PARAMETER PostInstallHook
        Defines the name of a script inside the installed module folder which should be executed after installation.
        Default: definition in directory file or 'Install.ps1'
#>
function Install-ModuleFromDirectory {
    [CmdletBinding()]
    param (
        [Parameter(Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, Mandatory=$true)]
        [String] $Module,