Question

I’m scripting the installation and configuration procedure for my company’s desktop application. We send out a kiosk and can’t put everything in the installer… moving right along! I’m using Start-Process to wait for msiexec to complete.

function Run-Installer
{
    param
    (
        [string] $msi = $(throw "Required parameter: 'msi'"),
    )

    if(-not(Test-Path $msi -Type Leaf))
    {
        throw "The installer could not be found: '$msi'"
    }

    $name = (Get-Item $msi).BaseName

    Write-Host "Installing $name"

    $p = 
    @(
        "/I `"$msi`"",                    # Install this MSI
        "/QN",                            # Quietly, without a UI
        "/L*V `"$ENV:TEMP\$name.log`""    # Verbose output to this log
    )

    Start-Process -FilePath "msiexec" -ArgumentList $p -Wait
}

Where I want to get fancy is with the log output from msiexec. I want to stream the contents of the log to the console while the installer is running. I’m guessing there are multiple parts to the solution

1. Running the installer in a background, waitable manner
2. Tailing the log file until some condition is met (installer job completes)
3. Optional: Filtering the output or writing to debug/verbose for fun

Answer 1

function Start-FileTail {
    param($path)
    # Get unique source ID
    $sourceID = "FileTailLine-" + [guid]::NewGuid()

    $job = Start-Job -ArgumentList $path, $sourceID {
        param($path,$sid)

        Register-EngineEvent -SourceIdentifier $sid -Forward

        do{}until(Test-Path $path)

        $fs = New-Object IO.FileStream ($path, [IO.FileMode]::Open, 
                [IO.FileAccess]::Read, [IO.FileShare]::ReadWrite)
        $sr = New-Object IO.StreamReader ($fs)
        $lines = @()

        while(1) {
            $line = $sr.ReadLine()
            $lines += $line
            # Send after every 100 reads
            if($lines.Count -gt 100) {
                # Join lines into 1 string
                $text = @($lines| where {$_} ) -join "`n"
                # Only send if text was found
                if($text){New-Event -SourceIdentifier $sid -MessageData $text}
                $lines = @()
            }
        }
    }

    $event = Register-EngineEvent -SourceIdentifier $sourceID -Action {
        Write-Host $event.MessageData
    }
    New-Object Object|
        Add-Member -Name Job -Type NoteProperty -Value $job -PassThru|
        Add-Member -Name SourceIdentifier -Type NoteProperty -Value $sourceID -PassThru
}

function Stop-FileTail {
    param($TailInfo)
    Remove-Job $TailInfo.Job -Force
    Unregister-Event -SourceIdentifier $tail.SourceIdentifier
}

You can remove the job, and unregister the event once the install is done.

Change Write-Host to Write-Verbose for -Verbose support

EDIT: I tested my answer while installing an application, and found that it was pretty slow when reading the log file. I updated the Get-Content call to use -ReadCount 100 to send the data as arrays of lines. The Write-Host line was updated to handle the arrays.

I also found that using the -Wait switch on Start-Process caused all of the log output to be written after the install was finished. This can be fixed by using:

$msi = Start-Process -FilePath "msiexec" -ArgumentList $p -PassThru
do{}until($msi.HasExited)

EDIT 2: Hmm, I don’t get all of the log file when I use -Wait and -ReadCount together. I put the reading of the log file back to how I originally had it. I’m not sure what to do about the speed yet.

EDIT 3: I’ve updated the code to use a StreamReader instead of Get-Content, and put the code into functions. You would then call it like:

$path = "$ENV:TEMP\$name.log"
if(Test-Path $path){Remove-Item $path}

$msi = Start-Process -FilePath "msiexec" -ArgumentList $p -PassThru
$tail = Start-FileTail $p
do{}until($msi.HasExited)
sleep 1 # Allow time to finish reading log.
Stop-FileTail $tail