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

Descrizione
-----------
Questo comando attende il completamento di tutti i processi in background in esecuzione nella sessione.

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

Descrizione
-----------
In questo esempio viene illustrato come utilizzare il cmdlet Wait-Job con processi avviati nei computer remoti tramite il cmdlet Start-Job. I comandi Start-Job e Wait-Job vengono inviati al computer remoto tramite il cmdlet Invoke-Command.

In questo esempio viene utilizzato Wait-Job per determinare se un comando Get-Date in esecuzione come processo in background in tre computer diversi è stato completato. 

Il primo comando crea una sessione di Windows PowerShell (PSSession) in ognuno dei tre computer remoti e la salva nella variabile $s. 

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire un comando Start-Job in ognuna delle tre sessioni in $s. Tutti i processi sono denominati Date1.

Il terzo comando utilizza il cmdlet Invoke-Command per eseguire un comando Wait-Job. Questo comando attende il completamento dei processi Date1 in ogni computer. Archivia l'insieme risultante di oggetti processo (matrice) nella variabile $done. 

Il quarto comando utilizza la proprietà Count della matrice di oggetti processo nell variabile $done per determinare quanti processi sono stati completati.

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}

Descrizione
-----------
In questo esempio viene utilizzato il parametro Any di Wait-Job per determinare quando viene completato il primo di numerosi processi in background in esecuzione nella sessione corrente. Viene inoltre illustrato come utilizzare il cmdlet Wait-Job per attendere il completamento dei processi remoti. 

Il primo comando crea una sessione PSSession in ognuno dei computer elencati nel file Machines.txt e archivia le sessioni nella variabile $s. Il comando utilizza il cmdlet Get-Content per ottenere il contenuto del file. Il comando Get-Content è racchiuso tra parentesi per garantire che venga eseguito prima del comando New-PSSession.

Il secondo comando archivia una stringa del comando Get-EventLog (tra virgolette) nella variabile $c.

Nel terzo comando viene utilizzato il cmdlet Invoke-Command per eseguire un comando Start-Job in ognuna delle sessioni di $s. Il comando Start-Job avvia un processo in background in cui viene eseguito il comando in $c. 

Poiché la variabile $c si trova nel computer locale, il comando utilizza la parola chiave "param" per dichiarare le variabili locali nel comando e il parametro ArgumentList per fornire i valori per tali variabili.

Nel quarto comando viene utilizzato il cmdlet Invoke-Command per eseguire un comando Wait-Job nelle sessioni. Viene utilizzato il cmdlet Wait-Job per attendere il completamento del primo processo nei computer remoti.

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}

Descrizione
-----------
In questo esempio viene illustrato come utilizzare il parametro Timeout di Wait-Job per impostare un tempo di attesa massimo per i processi in esecuzione in computer remoti. 

Il primo comando crea una sessione PSSession in ognuno dei tre computer remoti (Server01, Server02 e Server03) e salva le sessioni nella variabile $s. 

Nel secondo comando viene utilizzato il cmdlet Invoke-Command per eseguire un comando Start-Job in ognuna delle sessioni PSSession di $s. Il comando consente di salvare gli oggetti processo risultanti nella variabile $jobs.

Nel terzo comando viene utilizzato il cmdlet Invoke-Command per eseguire un comando Wait-Job in ognuna delle sessioni PSSession di $s. Il comando Wait-Job stabilisce se tutti i comandi sono stati completati entro 30 secondi. Utilizza il parametro Timeout con un valore di 30 (secondi) per stabilire il tempo di attesa massimo e salva i risultati del comando nella variabile $done. 

In questo caso, dopo 30 secondi, solo il comando nel computer Server02 è stato completato. Wait-Job interrompe l'attesa, visualizza il prompt dei comandi e restituisce l'oggetto che rappresenta il processo completato. 

La variabile $done contiene un oggetto processo che rappresenta il processo in esecuzione in Server02.

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

Descrizione
-----------
Questo comando identifica tre processi tramite i relativi ID e attese il completamento di uno di essi. Al termine del primo processo, viene visualizzato il prompt dei comandi.

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

Descrizione
-----------
Questo comando attende 120 secondi (due minuti) per il completamento del processo DailyLog. Se il processo non viene completato nei due minuti successivi, viene comunque visualizzato il prompt dei comandi e il processo continua ad essere eseguito in background.

C:\PS>wait-job -name Job3

Descrizione
-----------
Questo comando Wait-Job utilizza il nome del processo per identificare il processo da attendere.

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

Descrizione
-----------
In questo esempio viene illustrato come utilizzare il cmdlet Wait-Job con processi avviati nel computer locale tramite il cmdlet Start-Job.

Questi comandi avviano un processo che ottiene i file script di Windows PowerShell aggiunti o aggiornati nell'ultima settimana.

Nel primo comando viene utilizzato il cmdlet Start-Job per avviare un processo in background nel computer locale. Il processo esegue un comando Get-ChildItem che ottiene tutti i file con estensione ".ps1" aggiunti o aggiornati nell'ultima settimana.

Il terzo comando utilizza il cmdlet Wait-Job per attendere il completamento del processo. Al termine del processo, viene visualizzato l'oggetto processo che contiene informazioni sul processo.

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

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

C:\PS> $j | wait-job

Descrizione
-----------
In questo esempio viene illustrato come utilizzare il cmdlet Wait-Job con processi avviati nei computer remoti tramite il parametro AsJob del cmdlet Invoke-Command. Quando si utilizza AsJob, il processo viene creato nel computer locale e i risultati vengono automaticamente restituiti in tale computer, anche se il processo viene eseguito nei computer remoti.

In questo esempio viene utilizzato Wait-Job per determinare se un comando Get-Process in esecuzione nelle sessioni in tre computer remoti è stato completato. 

Il primo comando crea sessioni PSSession nei tre computer e le salva nella variabile $s. 

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire un comando Get-Process in ognuna delle tre sessioni PSSession in $s. Viene utilizzato il parametro AsJob per eseguire il comando in modo asincrono come processo in background. Il comando restituisce un oggetto processo, esattamente come i processi avviati tramite Start-Job e tale oggetto processo viene archiviato nella variabile $j.

Il terzo comando utilizza un operatore pipeline (|) per inviare l'oggetto processo in $j al cmdlet Wait-Job. Si noti che in questo caso non è richiesto un comando Invoke-Command, poiché il processo si trova nel computer locale.

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

Descrizione
-----------
Questo comando attende il processo con un valore ID pari a 1.