Powershell to wake up multiple media drives simultaneously

Question

I have a server with lots of media drives ~43TB. An areca 1882ix-16 is set to spin the drives down after 30 minutes of inactivity since most days an individual drive is not even used. This works nicely to prevent unnecessary power and heat. In this case the drives still show up in windows explorer but when you click to access them it takes about 10 seconds for the folder list to show up since it has to wait for the drive to spin up.

For administrative work I have a need to spin up all the drives to be able to search among them. Clicking on each drive in windows explorer and then waiting for it to spin up before clicking the next drive is very tedious. Obviously multiple explorer windows makes it faster but it is still tedious. I thought a powershell script may ease the pain.

So I started with the following:

$mediaDrives = @('E:', 'F:', 'G:', 'H:', 'I:', 'J:', 'K:', 'L:',
    'M:','N:', 'O:', 'P:', 'Q:', 'R:', 'S:')
get-childitem $mediaDrives  | foreach-object -process { $_.Name }

This is just requesting that each drive in the array have its root folder name listed. That works to wake the drive but it is again a linear function. The script pauses for each drive before printing. Looking for a solution as to how to wake each drive simultaneously. Is there a way to multi-thread or something else?

score 2 · Answer 1 · answered Dec 27 '12 at 17:39

Here's a script that will do what you want, but it must be run under powershell using the MTA threading mode (which is the default for powershell.exe 2.0, but powershell.exe 3.0 must be launched with the -MTA switch.)

#require -version 2.0

# if running in ISE or in STA console, abort
if (($host.runspace.apartmentstate -eq "STA") -or $psise) {
    write-warning "This script must be run under powershell -MTA"
    exit
}

$mediaDrives = @('E:', 'F:', 'G:', 'H:', 'I:', 'J:', 'K:', 'L:',
    'M:','N:', 'O:', 'P:', 'Q:', 'R:', 'S:')

# create a pool of 8 runspaces   
$pool = [runspacefactory]::CreateRunspacePool(1, 8)
$pool.Open()

$jobs = @()
$ps = @()
$wait = @()     

$count = $mediaDrives.Length

for ($i = 0; $i -lt $count; $i++) {

    # create a "powershell pipeline runner"
    $ps += [powershell]::create()  

    # assign our pool of 8 runspaces to use
    $ps[$i].runspacepool = $pool   

    # add wake drive command
    [void]$ps[$i].AddScript(
        "dir $($mediaDrives[$i]) > `$null")

    # start script asynchronously    
    $jobs += $ps[$i].BeginInvoke();         

    # store wait handles for WaitForAll call
    $wait += $jobs[$i].AsyncWaitHandle
}

# wait 5 minutes for all jobs to finish (configurable)
$success = [System.Threading.WaitHandle]::WaitAll($wait,
    (new-timespan -Minutes 5))     
write-host "All completed? $success"

# end async call   
for ($i = 0; $i -lt $count; $i++) {     
    write-host "Completing async pipeline job $i"    

    try {       
        # complete async job           
        $ps[$i].EndInvoke($jobs[$i])     
    } catch {   
        # oops-ee!          
        write-warning "error: $_"      
    }   

    # dump info about completed pipelines       
    $info = $ps[$i].InvocationStateInfo

    write-host "State: $($info.state) ; Reason: $($info.reason)"  
}

So, for example, save as warmup.ps1 and run like: powershell -mta c:\scripts\warmup.ps1

To read more about runspace pools and the general technique above, take a look at my blog entry about runspacepools:

http://nivot.org/blog/post/2009/01/22/CTP3TheRunspaceFactoryAndPowerShellAccelerators

I chose 8 pretty much arbitrarily for the parallelism factor - experiment yourself with lower or higher numbers.

Thanks for putting that together for me. However, it doesn't actually seem to spin up the drives in parallel. It takes 2.5 to 3 minutes for the script to complete and all the drives to be spun up. I wonder if this is something better served by writing a c# app. Seems multi-threading isn't something powershell does so well. If you have any pointers on writing a c# app for this let me know. — Dan, Dec 28 '12 at 17:06
maybe it just takes that long? try opening one console (cmd is fast) window for each drive and prepare each window by typing one drive identifier into each one, then alt tab through them all hitting enter to start them. time it. — x0n, Dec 29 '12 at 18:33

score 1 · Answer 2 · answered Dec 27 '12 at 10:02

1

Spin up a separate powershell instance for each drive or use workflows in PowerShell 3.0. Anyhow, you can pass drives directly to the Path parameter and skip Foreach-Object all togeteher:

Get-ChildItem $mediaDrives

answered Dec 27 '12 at 10:02

Shay Levy

121,444
32
184
206

score 1 · Answer 3 · answered Jan 01 '13 at 22:01

Have you considered approaching this with the Start-Job cmdlet:

$mediaDrives = @('E:', 'F:', 'G:', 'H:', 'I:', 'J:', 'K:')
$mediaDrives | ForEach-Object {
  Start-Job -ArgumentList $_ -ScriptBlock {param($drive)
    Get-ChildItem $drive
  }
}

The only clever part is that you need to use the -ArgumentList parameter on the Start-Job cmdlet to pass the correct value through for each iteration. This will create a background task that runs in parallel with the execution of the script. If you are curious

Hans Lub · Answer 4 · 2013-01-01T22:20:31.673

If you don't want to wait, well, don't wait: start those wake-up calls in the background.

In bash one would write

foreach drive ($mediadrives) {tickle_and_wake $drive &}

(note the ampersand, which means: start the command in the background, don't wait for it to complete)

In PowerShell that would translate to something like

foreach ($drive in $mediadrives)  {
   Start-Job {param($d) tickle_and_wake $d} -Arg $drive 
}

If you want confirmation that all background jobs have completed, use wait in bash or Wait-Job in Powershell

Powershell to wake up multiple media drives simultaneously

4 Answers4

Linked