Unpacking Software Livestream

Join our monthly Unpacking Software livestream to hear about the latest news, chat and opinion on packaging, software deployment and lifecycle management!

Learn More

Chocolatey Product Spotlight

Join the Chocolatey Team on our regular monthly stream where we put a spotlight on the most recent Chocolatey product releases. You'll have a chance to have your questions answered in a live Ask Me Anything format.

Learn More

Chocolatey Coding Livestream

Join us for the Chocolatey Coding Livestream, where members of our team dive into the heart of open source development by coding live on various Chocolatey projects. Tune in to witness real-time coding, ask questions, and gain insights into the world of package management. Don't miss this opportunity to engage with our team and contribute to the future of Chocolatey!

Learn More

Calling All Chocolatiers! Whipping Up Windows Automation with Chocolatey Central Management

Webinar from
Wednesday, 17 January 2024

We are delighted to announce the release of Chocolatey Central Management v0.12.0, featuring seamless Deployment Plan creation, time-saving duplications, insightful Group Details, an upgraded Dashboard, bug fixes, user interface polishing, and refined documentation. As an added bonus we'll have members of our Solutions Engineering team on-hand to dive into some interesting ways you can leverage the new features available!

Watch On-Demand
Chocolatey Community Coffee Break

Join the Chocolatey Team as we discuss all things Community, what we do, how you can get involved and answer your Chocolatey questions.

Watch The Replays
Chocolatey and Intune Overview

Webinar Replay from
Wednesday, 30 March 2022

At Chocolatey Software we strive for simple, and teaching others. Let us teach you just how simple it could be to keep your 3rd party applications updated across your devices, all with Intune!

Watch On-Demand
Chocolatey For Business. In Azure. In One Click.

Livestream from
Thursday, 9 June 2022

Join James and Josh to show you how you can get the Chocolatey For Business recommended infrastructure and workflow, created, in Azure, in around 20 minutes.

Watch On-Demand
The Future of Chocolatey CLI

Livestream from
Thursday, 04 August 2022

Join Paul and Gary to hear more about the plans for the Chocolatey CLI in the not so distant future. We'll talk about some cool new features, long term asks from Customers and Community and how you can get involved!

Watch On-Demand
Hacktoberfest Tuesdays 2022

Livestreams from
October 2022

For Hacktoberfest, Chocolatey ran a livestream every Tuesday! Re-watch Cory, James, Gary, and Rain as they share knowledge on how to contribute to open-source projects such as Chocolatey CLI.

Watch On-Demand

Downloads:

33,057

Downloads of v 2.0.0-alpha4:

491

Last Update:

21 Apr 2015

Package Maintainer(s):

Software Author(s):

  • SEEK Ltd.

Tags:

admin dsc

SEEK DSC Software

This is a prerelease version of SEEK DSC Software.

  • 1
  • 2
  • 3

2.0.0-alpha4 | Updated: 21 Apr 2015

Downloads:

33,057

Downloads of v 2.0.0-alpha4:

491

Software Author(s):

  • SEEK Ltd.

Tags:

admin dsc

SEEK DSC Software 2.0.0-alpha4

This is a prerelease version of SEEK DSC Software.

Legal Disclaimer: Neither this package nor Chocolatey Software, Inc. are affiliated with or endorsed by SEEK Ltd. The inclusion of SEEK Ltd. trademark(s), if any, upon this webpage is solely to identify SEEK Ltd. goods or services and not for commercial purposes.

  • 1
  • 2
  • 3

Some Checks Have Failed or Are Not Yet Complete

Not All Tests Have Passed


Validation Testing Unknown


Verification Testing Unknown


Scan Testing Successful:

No detections found in any package files

Details
Learn More

Deployment Method: Individual Install, Upgrade, & Uninstall

To install SEEK DSC Software, run the following command from the command line or from PowerShell:

>

To upgrade SEEK DSC Software, run the following command from the command line or from PowerShell:

>

To uninstall SEEK DSC Software, run the following command from the command line or from PowerShell:

>

Deployment Method:

NOTE

This applies to both open source and commercial editions of Chocolatey.

1. Enter Your Internal Repository Url

(this should look similar to https://community.chocolatey.org/api/v2/)


2. Setup Your Environment

1. Ensure you are set for organizational deployment

Please see the organizational deployment guide

2. Get the package into your environment

  • Open Source or Commercial:
    • Proxy Repository - Create a proxy nuget repository on Nexus, Artifactory Pro, or a proxy Chocolatey repository on ProGet. Point your upstream to https://community.chocolatey.org/api/v2/. Packages cache on first access automatically. Make sure your choco clients are using your proxy repository as a source and NOT the default community repository. See source command for more information.
    • You can also just download the package and push it to a repository Download

3. Copy Your Script

choco upgrade seek-dsc-software -y --source="'INTERNAL REPO URL'" --version="'2.0.0-alpha4'" --prerelease [other options]

See options you can pass to upgrade.

See best practices for scripting.

Add this to a PowerShell script or use a Batch script with tools and in places where you are calling directly to Chocolatey. If you are integrating, keep in mind enhanced exit codes.

If you do use a PowerShell script, use the following to ensure bad exit codes are shown as failures:


choco upgrade seek-dsc-software -y --source="'INTERNAL REPO URL'" --version="'2.0.0-alpha4'" --prerelease
$exitCode = $LASTEXITCODE

Write-Verbose "Exit code was $exitCode"
$validExitCodes = @(0, 1605, 1614, 1641, 3010)
if ($validExitCodes -contains $exitCode) {
  Exit 0
}

Exit $exitCode

- name: Install seek-dsc-software
  win_chocolatey:
    name: seek-dsc-software
    version: '2.0.0-alpha4'
    source: INTERNAL REPO URL
    state: present
    allow_prerelease: yes

See docs at https://docs.ansible.com/ansible/latest/modules/win_chocolatey_module.html.


chocolatey_package 'seek-dsc-software' do
  action    :install
  source   'INTERNAL REPO URL'
  version  '2.0.0-alpha4'
  options  '--prerelease'
end

See docs at https://docs.chef.io/resource_chocolatey_package.html.


cChocoPackageInstaller seek-dsc-software
{
    Name        = "seek-dsc-software"
    Version     = "2.0.0-alpha4"
    Source      = "INTERNAL REPO URL"
    chocoParams = "--prerelease"
}

Requires cChoco DSC Resource. See docs at https://github.com/chocolatey/cChoco.


package { 'seek-dsc-software':
  ensure          => '2.0.0-alpha4',
  install_options => ['--prerelease'],
  provider        => 'chocolatey',
  source          => 'INTERNAL REPO URL',
}

Requires Puppet Chocolatey Provider module. See docs at https://forge.puppet.com/puppetlabs/chocolatey.


4. If applicable - Chocolatey configuration/installation

See infrastructure management matrix for Chocolatey configuration elements and examples.

Package Approved

This package was approved as a trusted package on 21 Apr 2015.

Description

Custom DSC Resources for installing and uninstalling software packages and updates


lib\cSoftware\cSoftware.psd1
 
lib\cSoftware\DSCResources\SEEK_cPackageResource\en-US\MSFT_PackageResource.schema.mfl
 
lib\cSoftware\DSCResources\SEEK_cPackageResource\en-US\PackageProvider.psd1
 
lib\cSoftware\DSCResources\SEEK_cPackageResource\SEEK_cPackageResource.psm1
data LocalizedData
{
    # culture="en-US"
    # TODO: Support WhatIf
    ConvertFrom-StringData @'
InvalidIdentifyingNumber=The specified IdentifyingNumber ({0}) is not a valid Guid
InvalidPath=The specified Path ({0}) is not in a valid format. Valid formats are local paths, UNC, and HTTP
NeedsMoreInfo=Either Name or ProductId is required
InvalidBinaryType=The specified Path ({0}) does not appear to specify an EXE or MSI file and as such is not supported
CouldNotOpenLog=The specified LogPath ({0}) could not be opened
CouldNotStartProcess=The process {0} could not be started
UnexpectedReturnCode=The return code {0} was not expected. Configuration is likely not correct
PathDoesNotExist=The given Path ({0}) could not be found
CouldNotOpenDestFile=Could not open the file {0} for writing
CouldNotGetHttpStream=Could not get the HTTP stream for file {0}
ErrorCopyingDataToFile=Encountered error while writing the contents of {0} to {1}
PackageConfigurationComplete=Package configuration finished
PackageConfigurationStarting=Package configuration starting
InstalledPackage=Installed package
UninstalledPackage=Uninstalled package
NoChangeRequired=Package found in desired state, no action required
RemoveExistingLogFile=Remove existing log file
CreateLogFile=Create log file
MountSharePath=Mount share to get media
DownloadHTTPFile=Download the media over HTTP
StartingProcessMessage=Starting process {0} with arguments {1}
RemoveDownloadedFile=Remove the downloaded file
PackageInstalled=Package has been installed
PackageUninstalled=Package has been uninstalled
MachineRequiresReboot=The machine requires a reboot
PackageDoesNotAppearInstalled=The package {0} is not installed
PackageAppearsInstalled=The package {0} is already installed
PostValidationError=Package from {0} was installed, but the specified ProductId and/or Name does not match package details
'@
}

$Debug = $false
Function Trace-Message
{
    param([string] $Message)
    if($Debug)
    {
        Write-Verbose $Message
    }
}

$CacheLocation = "$env:ProgramData\Microsoft\Windows\PowerShell\Configuration\BuiltinProvCache\MSFT_PackageResource"

Function Throw-InvalidArgumentException
{
    param(
        [string] $Message,
        [string] $ParamName
    )

    $exception = new-object System.ArgumentException $Message,$ParamName
    $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception,$ParamName,"InvalidArgument",$null
    throw $errorRecord
}

Function Throw-TerminatingError
{
    param(
        [string] $Message,
        [System.Management.Automation.ErrorRecord] $ErrorRecord
    )

    $exception = new-object "System.InvalidOperationException" $Message,$ErrorRecord.Exception
    $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception,"MachineStateIncorrect","InvalidOperation",$null
    throw $errorRecord
}

Function Validate-StandardArguments
{
    param(
        $Path,
        $ProductId,
        $Name
    )

    Trace-Message "Validate-StandardArguments, Path was $Path"
    $uri = $null
    try
    {
        $uri = [uri] $Path
    }
    catch
    {
        Throw-InvalidArgumentException ($LocalizedData.InvalidPath -f $Path) "Path"
    }

    if($uri.Scheme -ne "file" -and $uri.Scheme -ne "http")
    {
        Throw-InvalidArgumentException ($LocalizedData.InvalidPath -f $Path) "Path"
    }

    $pathExt = [System.IO.Path]::GetExtension($Path)
    Trace-Message "The path extension was $pathExt"
    if(-not @(".msi",".exe") -contains $pathExt.ToLower())
    {
        Throw-InvalidArgumentException ($LocalizedData.InvalidBinaryType -f $Path) "Path"
    }

    $identifyingNumber = $null
    if(-not $Name -and -not $ProductId)
    {
        #It's a tossup here which argument to blame, so just pick ProductId to encourage customers to use the most efficient version
        Throw-InvalidArgumentException ($LocalizedData.NeedsMoreInfo -f $Path) "ProductId"
    }
    elseif($ProductId)
    {
        try
        {
            Trace-Message "Parsing $ProductId as an identifyingNumber"
            $identifyingNumber = "{{{0}}}" -f [Guid]::Parse($ProductId).ToString().ToUpper()
            Trace-Message "Parsed $ProductId as $identifyingNumber"
        }
        catch
        {
            Throw-InvalidArgumentException ($LocalizedData.InvalidIdentifyingNumber -f $ProductId) $ProductId
        }
    }

    return $uri, $identifyingNumber
}

Function Get-ProductEntry
{
    param
    (
        [string] $Name,
        [string] $IdentifyingNumber
    )

    $uninstallKey = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"
    $uninstallKeyWow64 = "HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall"

    if($IdentifyingNumber)
    {
        $keyLocation = "$uninstallKey\$identifyingNumber"
        $item = Get-Item $keyLocation -EA SilentlyContinue
        if(-not $item)
        {
            $keyLocation = "$uninstallKeyWow64\$identifyingNumber"
            $item = Get-Item $keyLocation -EA SilentlyContinue
        }

        return $item
    }

    foreach($item in (Get-ChildItem -EA Ignore $uninstallKey, $uninstallKeyWow64))
    {
        if($Name -eq (Get-LocalizableRegKeyValue $item "DisplayName"))
        {
            return $item
        }
    }

    return $null
}

function Test-TargetResource
{
    param
    (
        [ValidateSet("Present", "Absent")]
        [string] $Ensure = "Present",

        [parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [string] $Name,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [string] $Path,

        [parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [string] $ProductId,

        [string] $Arguments,

        [pscredential] $Credential,

        [int[]] $ReturnCode,

        [string] $LogPath
    )

    $uri, $identifyingNumber = Validate-StandardArguments $Path $ProductId $Name
    $product = Get-ProductEntry $Name $identifyingNumber
    Trace-Message "Ensure is $Ensure"
    Trace-Message "product is $product"
    Trace-Message ("product as boolean is {0}" -f [boolean]$product)
    $res = ($product -ne $null -and $Ensure -eq "Present") -or ($product -eq $null -and $Ensure -eq "Absent")
    if ($product -ne $null)
    {
        $name = Get-LocalizableRegKeyValue $product "DisplayName"
        Write-Verbose ($LocalizedData.PackageAppearsInstalled -f $name)
    }
    else
    {
        $displayName = $null
        if($Name)
        {
            $displayName = $Name
        }
        else
        {
            $displayName = $ProductId
        }

        Write-Verbose ($LocalizedData.PackageDoesNotAppearInstalled -f $displayName)
    }

    return $res
}

function Get-LocalizableRegKeyValue
{
    param(
        [object] $RegKey,
        [string] $ValueName
    )

    $res = $RegKey.GetValue("{0}_Localized" -f $ValueName)
    if(-not $res)
    {
        $res = $RegKey.GetValue($ValueName)
    }

    return $res
}

function Get-TargetResource
{
    param
    (
        [parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [string] $Name,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [string] $Path,

        [parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [string] $ProductId
    )

    #If the user gave the ProductId then it was passed through to $identifyingNumber
    $uri, $identifyingNumber = Validate-StandardArguments $Path $ProductId $Name

    $localMsi = $uri.IsFile -and -not $uri.IsUnc

    $product = Get-ProductEntry $Name $identifyingNumber

    if(-not $product)
    {
        return @{
            Ensure = "Absent"
            Name = $Name
            ProductId = $identifyingNumber
            Installed = $false
        }
    }

    #$identifyingNumber can still be null here (e.g. remote MSI with Name specified, local EXE)
    #If the user gave a ProductId just pass it through, otherwise fill it from the product
    if(-not $identifyingNumber)
    {
        $identifyingNumber = Split-Path -Leaf $product.Name
    }

    $date = $product.GetValue("InstallDate")
    if($date)
    {
        try
        {
            $date = "{0:d}" -f [DateTime]::ParseExact($date, "yyyyMMdd",[System.Globalization.CultureInfo]::CurrentCulture).Date
        }
        catch
        {
            $date = $null
        }
    }

    $publisher = Get-LocalizableRegKeyValue $product "Publisher"
    $size = $product.GetValue("EstimatedSize")
    if($size)
    {
        $size = $size/1024
    }

    $version = $product.GetValue("DisplayVersion")
    $description = $product.GetValue("Comments")
    $name = Get-LocalizableRegKeyValue $product "DisplayName"
    return @{
        Ensure = "Present"
        Name = $name
        Path = $Path
        InstalledOn = $date
        ProductId = $identifyingNumber
        Size = $size
        Installed = $true
        Version = $version
        PackageDescription = $description
        Publisher = $publisher
    }
}

function Set-TargetResource
{
    [CmdletBinding(SupportsShouldProcess=$true)]
    param
    (
        [ValidateSet("Present", "Absent")]
        [string] $Ensure = "Present",

        [parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [string] $Name,

        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [string] $Path,

        [parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [string] $ProductId,

        [string] $Arguments,

        [pscredential] $Credential,

        [int[]] $ReturnCode,

        [string] $LogPath
    )

    $ErrorActionPreference = "Stop"

    if((Test-TargetResource -Ensure $Ensure -Name $Name -Path $Path -ProductId $ProductId))
    {
        return
    }

    $uri, $identifyingNumber = Validate-StandardArguments $Path $ProductId $Name

    #Path gets overwritten in the download code path. Retain the user's original Path in case the install succeeded
    #but the named package wasn't present on the system afterward so we can give a better message
    $OrigPath = $Path

    Write-Verbose $LocalizedData.PackageConfigurationStarting
    if(-not $ReturnCode)
    {
        $ReturnCode = @(0)
    }

    $logStream = $null
    $psdrive = $null
    $downloadedFileName = $null
    try
    {
        $fileExtension = [System.IO.Path]::GetExtension($Path).ToLower()
        if($LogPath)
        {
            try
            {
                if($fileExtension -eq ".msi")
                {
                    #We want to pre-verify the path exists and is writable ahead of time
                    #even in the MSI case, as detecting WHY the MSI log doesn't exist would
                    #be rather problematic for the user
                    if((Test-Path $LogPath) -and $PSCmdlet.ShouldProcess($LocalizedData.RemoveExistingLogFile,$null,$null))
                    {
                        rm $LogPath
                    }

                    if($PSCmdlet.ShouldProcess($LocalizedData.CreateLogFile, $null, $null))
                    {
                        New-Item -Type File $LogPath | Out-Null
                    }
                }
                elseif($PSCmdlet.ShouldProcess($LocalizedData.CreateLogFile, $null, $null))
                {
                    $logStream = new-object "System.IO.StreamWriter" $LogPath,$false
                }
            }
            catch
            {
                Throw-TerminatingError ($LocalizedData.CouldNotOpenLog -f $LogPath) $_
            }
        }

        #Download or mount file as necessary
        if(-not ($fileExtension -eq ".msi" -and $Ensure -eq "Absent"))
        {
            if($uri.IsUnc -and $PSCmdlet.ShouldProcess($LocalizedData.MountSharePath, $null, $null))
            {
                $psdriveArgs = @{Name=([guid]::NewGuid());PSProvider="FileSystem";Root=(Split-Path $uri.LocalPath)}
                if($Credential)
                {
                    #We need to optionally include these and then splat the hash otherwise
                    #we pass a null for Credential which causes the cmdlet to pop a dialog up
                    $psdriveArgs["Credential"] = $Credential
                }

                $psdrive = New-PSDrive @psdriveArgs
                $Path = Join-Path $psdrive.Root (Split-Path -Leaf $uri.LocalPath) #Necessary?
            }
            elseif($uri.Scheme -eq "http" -and $Ensure -eq "Present" -and $PSCmdlet.ShouldProcess($LocalizedData.DownloadHTTPFile, $null, $null))
            {
                if(-not (Test-Path -PathType Container $CacheLocation))
                {
                    mkdir $CacheLocation | Out-Null
                }

                $destName = Join-Path $CacheLocation (Split-Path -Leaf $uri.LocalPath)

                Trace-Message "Need to download file from HTTP, destination will be $destName"
                Add-Type -AssemblyName System.Net.Http | Out-Null
                $client = New-Object System.Net.Http.HttpClient

                $outStream = $null
                $httpStream = $null
                try
                {
                    try
                    {
                        Trace-Message "Going to create the destination file"
                        $outStream = New-Object System.IO.FileStream $destName, "Create"
                        Trace-Message "Created the destination file"
                    }
                    catch
                    {
                        #Should never happen since we own the cache directory
                        Throw-TerminatingError ($LocalizedData.CouldNotOpenDestFile -f $destName) $_
                    }

                    try
                    {
                        Trace-Message "Going to create the HTTP stream"
                        $task = $client.GetStreamAsync($uri)
                        $task.Wait()
                        $httpStream = $task.Result
                        Trace-Message "Got the HTTP stream"
                    }
                    catch
                    {
                        Trace-Message ("Error: " + ($_ | Out-String))
                        Throw-TerminatingError ($LocalizedData.CouldNotGetHttpStream -f $Path) $_
                    }

                    try
                    {
                        Trace-Message "Copying the HTTP stream to the disk"
                        $httpStream.CopyTo($outStream)
                        Trace-Message "Copied the HTTP stream to the disk"
                    }
                    catch
                    {
                        Throw-TerminatingError ($LocalizedData.ErrorCopyingDataToFile -f $Path,$destName) $_
                    }
                }
                finally
                {
                    if($outStream)
                    {
                        $outStream.Dispose()
                    }

                    if($httpStream)
                    {
                        $httpStream.Dispose()
                    }
                }

                $Path = $downloadedFileName = $destName
            }
        }

        #At this point the Path ought to be valid unless it's an MSI uninstall case
        if(-not (Test-Path -PathType Leaf $Path) -and -not ($Ensure -eq "Absent" -and $fileExtension -eq ".msi"))
        {
            Throw-TerminatingError ($LocalizedData.PathDoesNotExist -f $Path)
        }

        $startInfo = New-Object System.Diagnostics.ProcessStartInfo
        $startInfo.UseShellExecute = $false #Necessary for I/O redirection and just generally a good idea
        $process = New-Object System.Diagnostics.Process
        $process.StartInfo = $startInfo
        $errLogPath = $LogPath + ".err" #Concept only, will never touch disk
        if($fileExtension -eq ".msi")
        {
            $startInfo.FileName = "$env:windir\system32\msiexec.exe"
            if($Ensure -eq "Present")
            {
                $startInfo.Arguments = '/i "{0}"' -f $Path
            }
            else
            {
                $product = Get-ProductEntry $Name $identifyingNumber
                $id = Split-Path -Leaf $product.Name #We may have used the Name earlier, now we need the actual ID
                $startInfo.Arguments = ("/x{0}" -f $id)
            }

            if($LogPath)
            {
                $startInfo.Arguments += ' /log "{0}"' -f $LogPath
            }

            $startInfo.Arguments += " /quiet"

            if($Arguments)
            {
                $startInfo.Arguments += " " + $Arguments
            }
        }
        else #EXE
        {
            Trace-Message "The binary is an EXE"
            $startInfo.FileName = $Path
            $startInfo.Arguments = $Arguments
            if($LogPath)
            {
                Trace-Message "User has requested logging, need to attach event handlers to the process"
                $startInfo.RedirectStandardError = $true
                $startInfo.RedirectStandardOutput = $true
                Register-ObjectEvent -InputObject $process -EventName "OutputDataReceived" -SourceIdentifier $LogPath
                Register-ObjectEvent -InputObject $process -EventName "ErrorDataReceived" -SourceIdentifier $errLogPath
            }
        }

        Trace-Message ("Starting {0} with {1}" -f $startInfo.FileName, $startInfo.Arguments)

        if($PSCmdlet.ShouldProcess(($LocalizedData.StartingProcessMessage -f $startInfo.FileName, $startInfo.Arguments), $null, $null))
        {
            try
            {
                $process.Start() | Out-Null
            }
            catch
            {
                Throw-TerminatingError ($LocalizedData.CouldNotStartProcess -f $Path) $_
            }

            if($logStream) #Identical to $fileExtension -eq ".exe" -and $logPath
            {
                $process.BeginOutputReadLine();
                $process.BeginErrorReadLine();
            }

            $process.WaitForExit()

            if($logStream)
            {
                #We have to re-mux these since they appear to us as different streams
                #The underlying Win32 APIs prevent this problem, as would constructing a script
                #on the fly and executing it, but the former is highly problematic from PowerShell
                #and the latter doesn't let us get the return code for UI-based EXEs
                $outputEvents = Get-Event -SourceIdentifier $LogPath
                $errorEvents = Get-Event -SourceIdentifier $errLogPath
                $masterEvents = @() + $outputEvents + $errorEvents
                $masterEvents = $masterEvents | Sort-Object -Property TimeGenerated

                foreach($event in $masterEvents)
                {
                    $logStream.Write($event.SourceEventArgs.Data);
                }

                Remove-Event -SourceIdentifier $LogPath
                Remove-Event -SourceIdentifier $errLogPath
            }

            $exitCode = $process.ExitCode
            if(-not ($ReturnCode -contains $exitCode))
            {
                Throw-TerminatingError ($LocalizedData.UnexpectedReturnCode -f $exitCode.ToString())
            }
        }
    }
    finally
    {
        if($psdrive)
        {
            Remove-PSDrive -Force $psdrive
        }

        if($logStream)
        {
            $logStream.Dispose()
        }
    }

    if($downloadedFileName -and $PSCmdlet.ShouldProcess($LocalizedData.RemoveDownloadedFile, $null, $null))
    {
        #This is deliberately not in the Finally block. We want to leave the downloaded file on disk
        #in the error case as a debugging aid for the user
        rm $downloadedFileName
    }

    $operationString = $LocalizedData.PackageUninstalled
    if($Ensure -eq "Present")
    {
        $operationString = $LocalizedData.PackageInstalled
    }

    if($Ensure -eq "Present")
    {
        #We can't do Test-TargetResource directly here because that would write spurious verbose entries
        $productEntry = Get-ProductEntry $Name $identifyingNumber
        if(-not $productEntry)
        {
            Throw-TerminatingError ($LocalizedData.PostValidationError -f $OrigPath)
        }
    }

    Write-Verbose $operationString
    Write-Verbose $LocalizedData.PackageConfigurationComplete
}

Export-ModuleMember -function Get-TargetResource, Set-TargetResource, Test-TargetResource
lib\cSoftware\DSCResources\SEEK_cPackageResource\SEEK_cPackageResource.schema.mof
 
lib\cSoftware\DSCResources\SEEK_cWindowsUpdate\SEEK_cWindowsUpdate.psm1
function Get-TargetResource
{
    [CmdletBinding()]
    [OutputType([System.Collections.Hashtable])]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update,

        [parameter(Mandatory = $true)]
        [System.String]
        $Kb
    )

    if (Test-UpdateInstalled($Kb))
    {
        return @{Update = $Update; Kb = $Kb; Ensure = "Present"}
    }

    return @{Update = $Update; Kb = $Kb; Ensure = "Absent"}
}


function Set-TargetResource
{
    [CmdletBinding()]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update,

        [parameter(Mandatory = $true)]
        [System.String]
        $Kb,

        [ValidateSet("Present","Absent")]
        [System.String]
        $Ensure  = "Present"
    )

    $installed = Test-UpdateInstalled($Kb)

    if(($Ensure -eq "Present") -and ($installed -eq $false))
    {
        Install-Update -Update $Update
    }
    elseif (($Ensure -eq "Absent") -and ($installed -eq $true))
    {
        Uninstall-Update -Update $Update
    }
}


function Test-TargetResource
{
    [CmdletBinding()]
    [OutputType([System.Boolean])]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update,

        [parameter(Mandatory = $true)]
        [System.String]
        $Kb,

        [ValidateSet("Present","Absent")]
        [System.String]
        $Ensure  = "Present"
    )

    $installed = Test-UpdateInstalled($Kb)

    if ($Ensure -eq "Present")
    {
        return $installed
    }
    else
    {
        return !$installed
    }
}

function Test-UpdateInstalled
{
    [CmdletBinding()]
    [OutputType([System.Boolean])]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Kb
    )

    $installed = Get-HotFix | Select-Object HotFixID | Select-String -Pattern $Kb -SimpleMatch -Quiet
    return ($installed -eq $true)
}

function Install-Update
{
    [CmdletBinding()]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update
    )

    Invoke-WindowsUpdateStandaloneInstaller -Update $Update
}

function Uninstall-Update
{
    [CmdletBinding()]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update
    )

    Invoke-WindowsUpdateStandaloneInstaller -Update $Update -Uninstall
}

function Invoke-WindowsUpdateStandaloneInstaller
{
    [CmdletBinding()]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update,

        [switch]
        $Uninstall = $false
    )

    $updateFile = Get-UpdateFile -Update $Update

    $updateArgs = @($updateFile, '/quiet', '/norestart')
    if($Uninstall)
    {
        $updateArgs = ,'/uninstall' + $updateArgs
    }

    Start-Process "${env:WINDIR}\system32\wusa.exe" -ArgumentList $updateArgs -Wait
}

# Downloads the update file if necssary and returns path of local file
function Get-UpdateFile
{
    [OutputType([System.String])]
    [CmdletBinding()]
    param
    (
        [parameter(Mandatory = $true)]
        [System.String]
        $Update

    )

    Write-Verbose "Update: ${Update}"

    $uri = $Update -as [System.URI]
    if(!$uri.IsFile)
    {
        # download remote file
        $updateFile = Join-Path $env:TEMP $uri.Segments[-1]
        Invoke-WebRequest $uri -OutFile $updateFile
        return $updateFile
    }

    return $Update
}

Export-ModuleMember -Function *-TargetResource
lib\cSoftware\DSCResources\SEEK_cWindowsUpdate\SEEK_cWindowsUpdate.schema.mof
 
tools\chocolateyInstall.ps1
try
{
	$DSCResourcesRoot = Join-Path $env:ProgramFiles "WindowsPowerShell\Modules"
	$DSCResourceTarget = Join-Path $env:chocolateyPackageFolder "lib"

	# remove DSC resources that may have been manually installed
	if (Test-Path "$DSCResourcesRoot\SEEK - Modules") {
		cmd /c rmdir "$DSCResourcesRoot\SEEK - Modules"
	}

	
	Get-ChildItem $DSCResourceTarget | Foreach-Object {
		if (Test-Path "$DSCResourcesRoot\$_") {
			# remove previous installation of this package
			cmd /c rmdir "$DSCResourcesRoot\$_"
		}
		cmd /c mklink /j "$DSCResourcesRoot\$_" "$DSCResourceTarget\$_"
		Get-ChildItem -Path "$DSCResourcesRoot\$_" -File -Recurse | Unblock-File
	}

	Write-ChocolateySuccess 'SEEK PowerShell DSC Resources'
} catch {
	Write-ChocolateyFailure 'SEEK PowerShell DSC Resources' $($_.Exception.Message)
	$host.SetShouldExit(1)
	throw $_
}
tools\chocolateyUninstall.ps1
try
{
	$DSCResourcesRoot = Join-Path $env:ProgramFiles "WindowsPowerShell\Modules"
	$DSCResourceTarget = Join-Path $env:chocolateyPackageFolder "lib"
	Get-ChildItem $DSCResourceTarget | Foreach-Object { cmd /c rmdir "$DSCResourcesRoot\$_" }

	Write-ChocolateySuccess 'SEEK PowerShell DSC Resources'
} catch {
	Write-ChocolateyFailure 'SEEK PowerShell DSC Resources' $($_.Exception.Message)
	throw $_
}

Log in or click on link to see number of positives.

In cases where actual malware is found, the packages are subject to removal. Software sometimes has false positives. Moderators do not necessarily validate the safety of the underlying software, only that a package retrieves software from the official distribution point and/or validate embedded software against official distribution point (where distribution rights allow redistribution).

Chocolatey Pro provides runtime protection from possible malware.

Add to Builder Version Downloads Last Updated Status
SEEK DSC Software 2.0.0.20230301-alpha9 110 Tuesday, January 3, 2023 Exempted
SEEK DSC Software 2.0.0-alpha9 554 Thursday, July 30, 2015 Approved
SEEK DSC Software 2.0.0-alpha7 444 Friday, May 1, 2015 Approved
SEEK DSC Software 2.0.0-alpha6 439 Wednesday, April 22, 2015 Approved
SEEK DSC Software 2.0.0-alpha5 421 Tuesday, April 21, 2015 Approved
SEEK DSC Software 2.0.0-alpha4 491 Tuesday, April 21, 2015 Approved
SEEK DSC Software 2.0.0-alpha2 457 Tuesday, February 24, 2015 Approved
SEEK DSC Software 2.0.0-alpha1 456 Monday, February 23, 2015 Approved
SEEK DSC Software 1.0.9-alpha6 432 Tuesday, June 9, 2015 Approved
SEEK DSC Software 1.0.9-alpha5 465 Tuesday, June 9, 2015 Approved
SEEK DSC Software 1.0.9-alpha4 445 Tuesday, June 9, 2015 Approved
SEEK DSC Software 1.0.9-alpha3 417 Tuesday, May 26, 2015 Approved
SEEK DSC Software 1.0.9-alpha2 440 Tuesday, May 26, 2015 Approved
SEEK DSC Software 1.0.9-alpha1 451 Friday, May 22, 2015 Approved
SEEK DSC Software 1.0.4 497 Friday, May 1, 2015 Approved
SEEK DSC Software 1.0.3 449 Wednesday, April 22, 2015 Approved
SEEK DSC Software 1.0.2 421 Tuesday, April 21, 2015 Approved
SEEK DSC Software 1.0.0.87 636 Sunday, February 22, 2015 Approved
SEEK DSC Software 1.0.0.77 485 Sunday, January 25, 2015 Approved
SEEK DSC Software 1.0.0.76 416 Wednesday, January 14, 2015 Approved
SEEK DSC Software 1.0.0.75 671 Tuesday, December 2, 2014 Approved
SEEK DSC Software 1.0.0.74 513 Sunday, November 9, 2014 Approved
SEEK DSC Software 1.0.0.73 451 Friday, November 7, 2014 Approved
SEEK DSC Software 1.0.0.72 419 Thursday, November 6, 2014 Approved
SEEK DSC Software 1.0.0.71 434 Thursday, November 6, 2014 Approved
SEEK DSC Software 1.0.0.70 409 Thursday, November 6, 2014 Approved
SEEK DSC Software 1.0.0.69 435 Monday, November 3, 2014 Approved
SEEK DSC Software 1.0.0.68 414 Monday, November 3, 2014 Approved
SEEK DSC Software 1.0.0.67 426 Monday, November 3, 2014 Approved
SEEK DSC Software 1.0.0.64 445 Thursday, October 30, 2014 Approved
SEEK DSC Software 1.0.0.63 383 Thursday, October 30, 2014 Approved
SEEK DSC Software 1.0.0.62 457 Monday, October 27, 2014 Approved
SEEK DSC Software 1.0.0.61 419 Friday, October 24, 2014 Approved
SEEK DSC Software 1.0.0.60 439 Friday, October 24, 2014 Approved
SEEK DSC Software 1.0.0.59 452 Friday, October 24, 2014 Approved
SEEK DSC Software 1.0.0.58 391 Friday, October 24, 2014 Approved
SEEK DSC Software 1.0.0.55 476 Friday, October 24, 2014 Approved
SEEK DSC Software 1.0.0.54 476 Wednesday, October 15, 2014 Approved
SEEK DSC Software 1.0.0.53 442 Wednesday, October 15, 2014 Approved
SEEK DSC Software 1.0.0.52 383 Wednesday, October 15, 2014 Approved
SEEK DSC Software 1.0.0.51 434 Wednesday, October 15, 2014 Approved
SEEK DSC Software 1.0.0.50 404 Sunday, October 12, 2014 Approved
SEEK DSC Software 1.0.0.48 406 Friday, October 10, 2014 Approved
SEEK DSC Software 1.0.0.47 433 Friday, October 10, 2014 Approved
SEEK DSC Software 1.0.0.46 401 Friday, October 10, 2014 Approved
SEEK DSC Software 1.0.0.45 454 Thursday, October 9, 2014 Approved
SEEK DSC Software 1.0.0.43 420 Wednesday, October 8, 2014 Approved
SEEK DSC Software 1.0.0.42 384 Wednesday, October 8, 2014 Approved
SEEK DSC Software 1.0.0.41 416 Thursday, October 2, 2014 Approved
SEEK DSC Software 1.0.0.40 442 Thursday, September 25, 2014 Approved
SEEK DSC Software 1.0.0.39 398 Thursday, September 25, 2014 Approved
SEEK DSC Software 1.0.0.37 419 Wednesday, September 24, 2014 Approved
SEEK DSC Software 1.0.0.36 414 Monday, September 22, 2014 Approved
SEEK DSC Software 1.0.0.35 396 Monday, September 15, 2014 Approved
SEEK DSC Software 1.0.0.34 362 Monday, September 15, 2014 Approved
SEEK DSC Software 1.0.0.33 379 Monday, September 15, 2014 Approved
SEEK DSC Software 1.0.0.32 392 Thursday, September 11, 2014 Approved
SEEK DSC Software 1.0.0.31 367 Wednesday, September 10, 2014 Approved
SEEK DSC Software 1.0.0.30 388 Wednesday, September 10, 2014 Approved
SEEK DSC Software 1.0.0.29 348 Wednesday, September 10, 2014 Approved
SEEK DSC Software 1.0.0.28 392 Tuesday, September 9, 2014 Approved
SEEK DSC Software 1.0.0.27 423 Tuesday, September 9, 2014 Approved
SEEK DSC Software 1.0.0.20 381 Tuesday, September 9, 2014 Approved
SEEK DSC Software 1.0.0.19 405 Tuesday, September 9, 2014 Approved
SEEK DSC Software 1.0.0.18 360 Tuesday, September 9, 2014 Approved
SEEK DSC Software 1.0.0.17 393 Tuesday, September 9, 2014 Approved
SEEK DSC Software 1.0.0.13 435 Friday, September 5, 2014 Approved
SEEK DSC Software 1.0.0.11 406 Friday, September 5, 2014 Approved
SEEK DSC Software 1.0.0 390 Tuesday, September 9, 2014 Approved
SEEK DSC Software 0.0.0.1 375 Tuesday, May 5, 2015 Approved

This package has no dependencies.

Discussion for the SEEK DSC Software Package

Ground Rules:

  • This discussion is only about SEEK DSC Software and the SEEK DSC Software package. If you have feedback for Chocolatey, please contact the Google Group.
  • This discussion will carry over multiple versions. If you have a comment about a particular version, please note that in your comments.
  • The maintainers of this Chocolatey Package will be notified about new comments that are posted to this Disqus thread, however, it is NOT a guarantee that you will get a response. If you do not hear back from the maintainers after posting a message below, please follow up by using the link on the left side of this page or follow this link to contact maintainers. If you still hear nothing back, please follow the package triage process.
  • Tell us what you love about the package or SEEK DSC Software, or tell us what needs improvement.
  • Share your experiences with the package, or extra configuration or gotchas that you've found.
  • If you use a url, the comment will be flagged for moderation until you've been whitelisted. Disqus moderated comments are approved on a weekly schedule if not sooner. It could take between 1-5 days for your comment to show up.
comments powered by Disqus