Wait-Job

Wait-Job [[-InstanceId] <Guid[]>] [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-Job] <Job[]> [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [[-Name] <string[]>] [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-Id] <Int32[]> [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-State {<NotStarted> | <Running> | <Completed> | <Failed> | <Stopped> | <Blocked>}] [-Any] [-Timeout <int>] [<CommonParameters>]

C:\PS>get-job | wait-job

Descrição
-----------
Esse comando aguarda que todos os trabalhos em segundo plano em execução na sessão sejam concluídos.

C:\PS>$s = new-pssession server01, server02, server03

C:\PS> invoke-command -session $s -scriptblock {start-job -name Date1 -scriptblock {get-date}}

C:\PS> $done = invoke-command -session $s -command {wait-job -name Date1}

C:\PS> $done.count
3

Descrição
-----------
Esse exemplo mostra como usar o cmdlet Wait-Job com trabalhos iniciados em computadores remotos com o uso do cmdlet Start-Job. Os comandos Start-Job e Wait-Job são enviados ao computador remoto com o uso do cmdlet Invoke-Command.

Esse exemplo usa Wait-Job para verificar se o comando Get-Date em execução como um trabalho em segundo plano em três computadores diferentes está concluído. 

O primeiro comando cria uma sessão do Windows PowerShell (PSSession) em cada um dos três computadores remotos e as armazena na variável $s. 

O segundo comando usa o cmdlet Invoke-Command para executar um comando Start-Job em cada uma das três sessões em $s. Todos os trabalhos são denominados Date1.

O terceiro comando usa o cmdlet Invoke-Command para executar um comando Wait-Job. Esse comando aguarda a conclusão dos trabalhos Date1 em cada computador. Ele armazena o conjunto (matriz) resultante de objetos de trabalho na variável $done. 

O quarto comando usa a propriedade Count da matriz de objetos de trabalho na variável $done para determinar quantos trabalhos estão concluídos.

C:\PS>$s = new-pssession (get-content machines.txt)  

C:\PS> $c = 'get-eventlog -log system | where {$_.EntryType -eq "error" -and $_.Source -eq "LSASRV"} | out-file errors.txt'

C:\PS> invoke-command -session $s -scriptblock {param($c)start-job -scriptblock {$c}} -ArgumentList $c

C:\PS> invoke-command -session $s -scriptblock {wait-job -any}

Descrição
-----------
Esse exemplo usa o parâmetro Any de Wait-Job para determinar quando o primeiro de muitos trabalhos em segundo plano em execução na sessão atual está concluído. Ele também mostra como usar o cmdlet Wait-Job para aguardar a conclusão de trabalhos remotos. 

O primeiro comando cria uma PSSession em cada um dos computadores listados no arquivo Machines.txt e armazena as PSSessions na variável $s. O comando usa o cmdlet Get-Content para obter o conteúdo do arquivo. O comando Get-Content é colocado entre parênteses para garantir que seja executado antes do comando New-PSSession.

O segundo comando armazena uma cadeia de caracteres (entre aspas) do comando Get-EventLog na variável $c.

O terceiro comando usa o cmdlet Invoke-Command para executar um comando Start-Job em cada uma das sessões em $s. O comando Start-Job inicia um trabalho em segundo plano que executa o comando em $c. 

Como a variável $c está no computador local, o comando usa a palavra-chave "param" para declarar as variáveis locais no comando e o parâmetro ArgumentList para fornecer os valores dessas variáveis.

O quarto comando usa o cmdlet Invoke-Command para executar um comando Wait-Job nas sessões. Ele usa o cmdlet Wait-Job para aguardar até que o primeiro trabalho esteja concluído nos computadores remotos.

C:\PS>$s = new-pssession Server01, Server02, Server03 

C:\PS> $jobs = invoke-command -session $s -scriptblock {start-job -script {get-date}}

C:\PS> $done = invoke-command -session $s -scriptblock {wait-job -timeout 30}

Descrição
-----------
Esse exemplo mostra como usar o parâmetro Timeout de Wait-Job para definir um tempo de espera máximo para os trabalhos em execução nos computadores remotos. 

O primeiro comando cria uma PSSession em cada um dos três computadores remotos (Server01, Server02 e Server03) e salva as PSSessions na variável $s. 

O segundo comando usa o cmdlet Invoke-Command para executar um comando Start-Job em cada uma das PSSessions em $s. Ele salva os objetos de trabalho resultantes na variável $jobs.

O terceiro comando usa o cmdlet Invoke-Command para executar um comando Wait-Job em cada uma das PSSessions em $s. O comando Wait-Job verifica se todos os comandos foram concluídos em 30 segundos. Ele usa o parâmetro Timeout com um valor igual a 30 (segundos) para estabelecer o tempo de espera máximo e salva os resultados do comando na variável $done. 

Neste caso, depois de 30 segundos, somente o comando no computador Server02 foi concluído. Wait-Job termina a espera, exibe o prompt de comando e retorna o objeto que representa o trabalho concluído. 

A variável $done contém um objeto de trabalho que representa o trabalho executado em Server02.

C:\PS>wait-job -id 1,2,5 -any

Descrição
-----------
Esse comando identifica três trabalhos por suas IDs e aguarda até que um deles esteja concluído. O prompt de comando retorna quando o primeiro trabalho é concluído.

C:\PS>wait-job -name DailyLog -timeout 120

Descrição
-----------
Esse comando espera 120 segundos (dois minutos) pela conclusão do trabalho DailyLog. Se o trabalho não for concluído nos próximos dois minutos, o prompt de comando retorna de qualquer maneira e o trabalho continua a ser executado em segundo plano.

C:\PS>wait-job -name Job3

Descrição
-----------
Esse comando Wait-Job usa o nome do trabalho para identificar o trabalho a ser aguardado.

C:\PS>C:\PS> $j = start-job -script {get-childitem *.ps1| where {$_lastwritetime -gt ((get-date) - (new-timespan -days 7))}}

C:\PS> $j | wait-job

Descrição
-----------
Esse exemplo mostra como usar o cmdlet Wait-Job com trabalhos iniciados no computador local com o uso do cmdlet Start-Job.

Esses comandos iniciam um trabalho que obtém os arquivos de script do Windows PowerShell que foram adicionados ou atualizados na última semana.

O primeiro comando usa o cmdlet Start-Job para iniciar um trabalho em segundo no computador local. O trabalho é executado no comando Get-ChildItem que obtém todos os arquivos com a extensão de nome de arquivo ".ps1" que foi adicionada ou atualizada na última semana.

O terceiro comando usa o cmdlet Wait-Job para aguardar até que o trabalho esteja concluído. Quando o trabalho é concluído, o comando exibe o objeto de trabalho, que contém informações sobre o trabalho.

C:\PS>$s = new-pssession Server01, Server02, Server03

C:\PS> $j = invoke-command -session $s -scriptblock {get-process} -asjob

C:\PS> $j | wait-job

Descrição
-----------
Esse exemplo mostra como usar o cmdlet Wait-Job com trabalhos iniciados em computadores remotos com o uso do parâmetro AsJob do cmdlet Invoke-Command. Quando se usa AsJob, o trabalho é criado no computador local, e os resultados são automaticamente retornados para o computador local, mesmo que o trabalho seja executado nos computadores remotos.

Esse exemplo usa Wait-Job para verificar se um comando Get-Process em execução nas sessões de três computadores remotos está concluído. 

O primeiro comando cria PSSessions nos três computadores e as armazena na variável $s. 

O segundo comando usa o cmdlet Invoke-Command para executar um comando Get-Process em cada uma das três PSSessions em $s. O comando usa o parâmetro AsJob para executar o comando de modo assíncrono como um trabalho em segundo plano. O comando retorna um objeto de trabalho, exatamente como os trabalhos iniciados com o uso de Start-Job, e o objeto de trabalho é armazenado na variável $j.

O terceiro comando usa um operador de pipeline (|) para enviar o objeto de trabalho em $j para o cmdlet Wait-Job. Observe que um comando Invoke-Command comando não é necessário nesse caso, porque o trabalho reside no computador local.

C:\PS>get-job

Id   Name     State      HasMoreData     Location             Command
--   ----     -----      -----------     --------             -------
1    Job1     Completed  True            localhost,server01.. get-service
4    Job4     Completed  True            localhost            dir | where

C:\PS> wait-job -id 1

Descrição
-----------
Esse comando aguarda o trabalho com um valor de ID igual a 1.