{"id":132,"date":"2011-02-04T17:47:50","date_gmt":"2011-02-05T00:47:50","guid":{"rendered":"http:\/\/ryan.witschger.net\/?p=132"},"modified":"2011-02-04T17:47:50","modified_gmt":"2011-02-05T00:47:50","slug":"getting-the-progress-of-a-child-thread-in-powershell","status":"publish","type":"post","link":"http:\/\/www.Get-Blog.com\/?p=132","title":{"rendered":"Getting the Progress of a Child Thread in PowerShell"},"content":{"rendered":"

My most popular article has thus far been the post over multithreading found here<\/a>. As such I felt that my audience might like to see some more entries covering that topic. After all, it is a vast topic with a lot of very advanced things you can do. In this post I would like to talk about tracking the status of your various threads. In other words, how can you see a progress of what your child script is doing?<\/p>\n

In exploring this myself, I worked with passing custom objects back to the parent which held various status messages that the parent could read in with the “receive-job” command. That actually worked, but it took a lot of code in both the parent and the child to generate and read the status from the child threads.<\/p>\n

While working with this, though, I found that the Job object from “get-job”, a System.Management.Automation.Job, has a property called “Progress”. I then decided to look into how this actually gets filled out. And the answer eluded my research until I managed to do it, completely by accident. As it turns out, this very useful property is filled in automatically by a “write-progress” command run within the child thread. It is actually quite logical that the progress field is filled in by “write-progress”.<\/p>\n

So, that is enough of a background on how I came about it. Let’s actually look at some code. First,I want to create a script block to run within my child job.<\/p>\n

## Write some code for the child threads to execute<\/span>
\n$ThreadCode<\/span> =<\/span> {<\/span>
\n    $x<\/span> =<\/span> 0<\/span>
\n    $time<\/span> =<\/span> 200<\/span>
\n    While<\/span> (<\/span>$x<\/span> -lt<\/span> 100<\/span>)<\/span>{<\/span>
\n        $x<\/span>++<\/span>
\n
\n        Write-Progress<\/span>  -Activity<\/span> "Testing"<\/span>
\n            -Status<\/span> "Testing"<\/span>
\n            -PercentComplete<\/span> $X<\/span>
\n            -completed<\/span>
\n        Start-Sleep<\/span> -Milliseconds<\/span> $time<\/span>
\n    }<\/span>
\n    Write-Progress<\/span>  -Activity<\/span> "Testing"<\/span>
\n            -Status<\/span> "Testing"<\/span>
\n            -PercentComplete<\/span> 100<\/span>
\n            -Completed<\/span>
\n    "Annnd we're done."<\/span>
\n}<\/span><\/div><\/div>\n

So here you’ll notice that I am basically creating a loop that will count 1 to 100 and then close. Along the way it will fill out its progress with the “write-progress” cmdlet. The one important note is that I am adding the “-completed” parameter to the “write-progress” cmdlet. That may look like a mistake in the code,but it isn’t. If you play around with this manner of getting progress from a child you will notice that when you run a “receive-job” your host thread will read all output from the child, including flashing all of the “write-progress” bars that were in the child. If you actually read the help files for “write-progress”, you’ll see that actual description of the functionality of “-complete” states that is simply hides the output bar. We need to do this so that when the parent thread runs a “receive-job” there is no odd behavior for the end user.<\/p>\n

## Kill any current jobs in the sessions and get rid of them<\/span>
\nGet-<\/span>Job |<\/span> Stop-<\/span>Job
\nGet-<\/span>Job |<\/span> Remove-<\/span>Job
\n
\n## Start the child job and assign to a variable to save some code later<\/span>
\n$Job<\/span> =<\/span> Start-<\/span>Job -<\/span>ScriptBlock $ThreadCode<\/div><\/div>\n

So for this quick snippet we are just closing an remove any jobs our current session may have, and then starting our job. I assign it to a variable so we don’t have to track it down later, not that it’s hard.<\/p>\n

While<\/span> (<\/span>$Job<\/span>.State -eq<\/span> "Running"<\/span>)<\/span>{<\/span>
\n    ## Get the Child job object<\/span>
\n    $Child<\/span> =<\/span> $Job<\/span>.ChildJobs[<\/span>0<\/span>]<\/span>
\n   
\n    ## Get the newest Progress Object in the child job<\/span>
\n    $Progress<\/span> =<\/span> $Child<\/span>.Progress[<\/span>$Child<\/span>.Progress.Count -<\/span> 1<\/span>]<\/span>
\n
\n    ## If the progress object is not null<\/span>
\n    If<\/span> (<\/span>$Progress<\/span>.Activity -ne<\/span> $Null<\/span>)<\/span>{<\/span>
\n        Write-Progress<\/span>  -Activity<\/span> $Job<\/span>.Name
\n                        -Status<\/span> $Progress<\/span>.StatusDescription
\n                        -PercentComplete<\/span> $Progress<\/span>.PercentComplete
\n                        -ID<\/span> $Job<\/span>.ID
\n    }<\/span>
\n   
\n    Start-Sleep<\/span> -Milliseconds<\/span> 200<\/span>
\n}<\/span><\/div><\/div>\n

So this is the bread and butter of the parent script. It simply loops around as long as our job is running. First we need to find the child job to our parent job. I am not sure why Microsoft chose to design it like this, but each job you start actually runs commands in a child job. I have a feeling it has something to do with functionality with Windows HPC, but that is neither here nor there. Once we have our child job, we want to find the latest progress object that has been passed. After that I just check to see if the object is empty, because the first check may not have given the child thread enough time to fill this out. If there is data, then we can fill out a “write-progress” bar on our host thread. From there we just repeat until the job is done.<\/p>\n

Get-<\/span>Job |<\/span> Receive-<\/span>Job<\/div><\/div>\n

At the end we just want to read anything the child script may actually have sent. So that covers it. It is really easy to get custom progress bars for a child process because there is a good, built in method to do it.<\/p>\n

Following is a full example of a script which will launch three child threads at a time until there have been 10 opened total. It will show you the output of each thread as it completes and the progress bars produced by each. I even included a random speed that each child will complete so you can see some bells and whistles going.<\/p>\n

## Write some code for the child threads to execute<\/span>
\n$ThreadCode<\/span> =<\/span> {<\/span>
\n    $x<\/span> =<\/span> 0<\/span>
\n    $time<\/span> =<\/span> Get-<\/span>Random -Maximum<\/span> 200<\/span> -<\/span>SetSeed $(<\/span>Get-Date<\/span>)<\/span>.Millisecond
\n    While<\/span> (<\/span>$x<\/span> -lt<\/span> 100<\/span>)<\/span>{<\/span>
\n        $x<\/span>++<\/span>
\n
\n        Write-Progress<\/span> -Activity<\/span> "Testing"<\/span> -Status<\/span> "Testing"<\/span> -PercentComplete<\/span> $X<\/span> -completed<\/span>
\n        Start-Sleep<\/span> -Milliseconds<\/span> $time<\/span>
\n    }<\/span>
\n    Write-Progress<\/span> -Activity<\/span> "Testing"<\/span> -Status<\/span> "Testing"<\/span> -PercentComplete<\/span> 100<\/span> -Completed<\/span>
\n    "Annnd we're done."<\/span>
\n}<\/span>
\n
\n## Kill any current jobs in the sessions and get rid of them<\/span>
\nGet-<\/span>Job |<\/span> Stop-<\/span>Job
\nGet-<\/span>Job |<\/span> Remove-<\/span>Job
\n
\n## Loop control<\/span>
\n$x<\/span> =<\/span> 0<\/span>
\n
\n## While we are still launching threads or wait for them to close<\/span>
\nWhile<\/span> (<\/span>(<\/span>$x<\/span> -lt<\/span> 10<\/span>)<\/span> -or<\/span> (<\/span>$(<\/span>Get-<\/span>Job -<\/span>State "Running"<\/span>)<\/span>.count -gt<\/span> 0<\/span>)<\/span>)<\/span>{<\/span>
\n    ## While there are less than three jobs running and less than 10 have started<\/span>
\n    While<\/span> (<\/span>(<\/span>$(<\/span>Get-<\/span>Job -<\/span>State "Running"<\/span>)<\/span>.count -lt<\/span> 3<\/span>)<\/span> -and<\/span> (<\/span>$x<\/span> -lt<\/span> 10<\/span>)<\/span>)<\/span>{<\/span>
\n        Start-<\/span>Job -<\/span>ScriptBlock $ThreadCode<\/span> |<\/span> Out-Null<\/span>
\n        $x<\/span>++<\/span>
\n    }<\/span>
\n   
\n    ## Main portion - Read all jobs<\/span>
\n    ForEach<\/span> (<\/span>$Job<\/span> in<\/span> Get-<\/span>Job)<\/span> {<\/span>
\n        ## Read all children of all jobs<\/span>
\n        ForEach<\/span> (<\/span>$Child<\/span> in<\/span> $Job<\/span>.ChildJobs)<\/span>{<\/span>
\n            ## Get the latest progress object of the job<\/span>
\n            $Progress<\/span> =<\/span> $Child<\/span>.Progress[<\/span>$Child<\/span>.Progress.Count -<\/span> 1<\/span>]<\/span>
\n           
\n            ## If there is a progress object returned write progress<\/span>
\n            If<\/span> (<\/span>$Progress<\/span>.Activity -ne<\/span> $Null<\/span>)<\/span>{<\/span>
\n                Write-Progress<\/span>  -Activity<\/span> $Job<\/span>.Name
\n                                -Status<\/span> $Progress<\/span>.StatusDescription
\n                                -PercentComplete<\/span> $Progress<\/span>.PercentComplete
\n                                -ID<\/span> $Job<\/span>.ID
\n            }<\/span>
\n           
\n            ## If this child is complete then stop writing progress<\/span>
\n            If<\/span> (<\/span>$Progress<\/span>.PercentComplete -eq<\/span> 100<\/span>)<\/span>{<\/span>
\n                Write-Progress<\/span>  -Activity<\/span> $Job<\/span>.Name
\n                                -Status<\/span> $Progress<\/span>.StatusDescription
\n                                -PercentComplete<\/span> $Progress<\/span>.PercentComplete
\n                                -ID<\/span> $Job<\/span>.ID
\n                                -<\/span>Complete
\n                ## Clear all progress entries so we don't process it again<\/span>
\n                $Child<\/span>.Progress.Clear<\/span>(<\/span>)<\/span>
\n            }<\/span>
\n        }<\/span>
\n    }<\/span>
\n   
\n    Get-<\/span>Job -<\/span>State "Completed"<\/span> |<\/span> Receive-<\/span>Job
\n   
\n    ## Setting for loop processing speed<\/span>
\n    Start-Sleep<\/span> -Milliseconds<\/span> 200<\/span>
\n}<\/span>
\n
\nGet-<\/span>Job |<\/span> Wait-<\/span>Job |<\/span> Out-Null<\/span>
\nGet-<\/span>Job |<\/span> Receive-<\/span>Job<\/div><\/div>\n","protected":false},"excerpt":{"rendered":"

In this post I would like to talk about tracking the status of your various threads. In other words, how can you see a progress of what your child script is doing?<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_mi_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[4],"tags":[],"_links":{"self":[{"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=\/wp\/v2\/posts\/132"}],"collection":[{"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=132"}],"version-history":[{"count":0,"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=\/wp\/v2\/posts\/132\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=132"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=132"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.Get-Blog.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=132"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}