Supprime l'invite de commandes jusqu'à ce qu'une des tâches ou toutes les tâches en arrière-plan de Windows PowerShell s'exécutant dans la session soient terminées.
Syntaxe
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>]
Description
L'applet de commande Wait-Job attends que les tâches en arrière-plan de Windows PowerShell s'achèvent pour afficher l'invite de commandes. Vous pouvez attendre que l'une des tâches en arrière-plan ou l'ensemble de ces tâches soit terminé, et définir un délai d'attente maximal pour les tâches.
Vous pouvez utiliser Wait-Job pour obtenir des tâches en arrière-plan démarrées à l'aide de Start-Job ou du paramètre AsJob d'Invoke-Command.
Lorsque les commandes de la tâche sont terminées, Wait-Job affiche l'invite de commandes et retourne un objet de traitement pour que vous puissiez le diriger vers une autre commande.
Paramètres
-Any
Affiche l'invite de commandes (et retourne l'objet de traitement) à la fin de toute tâche. Par défaut, Wait-Job attend la fin de toutes les tâches spécifiées avant d'afficher l'invite.
|
Obligatoire ? |
false |
|
Position ? |
named |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
false |
|
Accepter les caractères génériques ? |
false |
-Id <Int32[]>
Attend les tâches ayant les ID spécifiés.
L'ID est un entier qui identifie de manière unique la tâche dans la session active. Il est plus facile à mémoriser et à taper que l'InstanceId, mais est seulement unique dans la session active. Vous pouvez taper un ou plusieurs ID (séparés par des virgules). Pour rechercher l'ID d'une tâche, tapez « Get-Job » sans paramètres.
|
Obligatoire ? |
true |
|
Position ? |
1 |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
true (ByPropertyName) |
|
Accepter les caractères génériques ? |
false |
-InstanceId <Guid[]>
Attend les tâches ayant les ID d'instance spécifiés. La valeur par défaut est toutes les tâches.
Un ID d'instance est un GUID qui identifie de manière unique la tâche sur l'ordinateur. Pour rechercher l'ID d'instance d'une tâche, utilisez Get-Job.
|
Obligatoire ? |
false |
|
Position ? |
1 |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
true (ByPropertyName) |
|
Accepter les caractères génériques ? |
false |
-Job <Job[]>
Attend les tâches spécifiées. Entrez une variable qui contient les objets de traitement ou une commande permettant d'obtenir ces objets. Vous pouvez également utiliser un opérateur de pipeline pour envoyer des objets de traitement à l'applet de commande Wait-Job. Par défaut, Wait-Job attend toutes les tâches créées dans la session active.
|
Obligatoire ? |
true |
|
Position ? |
1 |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
true (ByValue, ByPropertyName) |
|
Accepter les caractères génériques ? |
false |
-Name <string[]>
Attend les tâches ayant le nom convivial spécifié.
|
Obligatoire ? |
false |
|
Position ? |
1 |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
true (ByPropertyName) |
|
Accepter les caractères génériques ? |
false |
-State <JobState>
Attend les tâches ayant l'état spécifié. Les valeurs valides sont NotStarted, Running, Completed, Stopped, Failed et Blocked.
|
Obligatoire ? |
false |
|
Position ? |
named |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
true (ByPropertyName) |
|
Accepter les caractères génériques ? |
false |
-Timeout <int>
Détermine le délai d'attente maximal pour chaque tâche en arrière-plan, en secondes. La valeur par défaut, -1, attend jusqu'à la fin de la tâche, quelle que soit sa durée d'exécution. Le calcul du temps démarre lorsque vous envoyez la commande Wait-Job, et non la commande Start-Job.
Si cette période est dépassée, l'attente se termine et l'invite de commandes réapparaît, même si la tâche est encore en cours d'exécution. Aucun message d'erreur n'est affiché.
|
Obligatoire ? |
false |
|
Position ? |
named |
|
Valeur par défaut |
|
|
Accepter l'entrée de pipeline ? |
false |
|
Accepter les caractères génériques ? |
false |
<CommonParameters>
Cette applet de commande prend en charge les paramètres courants : -Verbose, -Debug, -ErrorAction, -ErrorVariable, -OutBuffer et -OutVariable. Pour plus d'informations, consultez about_Commonparameters.
Entrées et sorties
Le type d'entrée est le type des objets que vous pouvez diriger vers l'applet de commande. Le type de retour est le type des objets que l'applet de commande retourne.
|
Entrées |
System.Management.Automation.RemotingJob Vous pouvez diriger un objet de traitement vers Wait-Job. |
|
Sorties |
System.Management.Automation.RemotingJob Wait-Job retourne les objets de traitement qui représentent les tâches terminées. Si l'attente se termine suite au dépassement de la valeur du paramètre Timeout, Wait-Job ne retourne aucun objet. |
Exemple 1
C:\PS>get-job | wait-job Description ----------- Cette commande attend que toutes les tâches en arrière-plan qui s'exécutent dans la session se terminent.
Exemple 2
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
Description
-----------
Cet exemple montre comment utiliser l'applet de commande Wait-Job avec des tâches démarrées sur des ordinateurs distants à l'aide de l'applet de commande Start-Job. Les commandes Start-Job et Wait-Job sont soumises à l'ordinateur distant à l'aide de l'applet de commande Invoke-Command.
Cet exemple utilise Wait-Job pour déterminer si une commande Get-Date qui s'exécute comme une tâche en arrière-plan sur trois ordinateurs différents est terminée.
La première commande crée une session Windows PowerShell (PSSession) sur chacun des trois ordinateurs distants et stocke ces sessions dans la variable $s.
La deuxième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Start-Job dans chacune des trois sessions dans $s. Toutes les tâches sont nommées Date1.
La troisième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Wait-Job. Cette commande attend que les tâches Date1 se terminent sur chaque ordinateur. Elle stocke la collection résultante (tableau) d'objets de traitement dans la variable $done.
La quatrième commande utilise la propriété Count du tableau d'objets de traitement dans la variable $done pour déterminer combien de tâches sont terminées.
Exemple 3
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}
Description
-----------
Cet exemple utilise le paramètre Any de Wait-Job pour déterminer quand la première de nombreuses tâches en arrière-plan qui s'exécutent dans la session active se termine. Elle montre également comment utiliser l'applet de commande Wait-Job pour attendre que les tâches distantes se terminent.
La première commande crée une session PSSession sur chacun des ordinateurs répertoriés dans le fichier Machines.txt et stocke les sessions PSSession dans la variable $s. Elle utilise l'applet de commande Get-Content pour obtenir le contenu du fichier. La commande Get-Content est placée entre parenthèses pour s'assurer qu'elle s'exécute avant la commande New-PSSession.
Le deuxième commande stocke une chaîne de commande Get-EventLog (entre guillemets) dans la variable $c.
La troisième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Start-Job dans chacune des sessions PSSession de $s. La commande Start-Job démarre une tâche en arrière-plan qui exécute la commande dans $c.
Étant donné que la variable $c se trouve sur l'ordinateur local, le mot clé « param » est utilisé pour déclarer les variables locales dans la commande et le paramètre ArgumentList pour fournir des valeurs pour ces variables.
La quatrième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Wait-Job dans les sessions. Elle fait appel à l'applet de commande Wait-Job pour attendre que la première tâche se termine sur les ordinateurs distants.
Exemple 4
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}
Description
-----------
Cet exemple montre comment utiliser le paramètre Timeout de Wait-Job pour définir un délai d'attente maximal pour les tâches qui s'exécutent sur les ordinateurs distants.
La première commande crée une session PSSession sur chacun des trois ordinateurs distants (Server01, Server02 et Server03), puis enregistre les sessions PSSession dans la variable $s.
La deuxième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Start-Job dans chacune des sessions PSSession dans $s. Elle enregistre les objets de traitement résultants dans la variable $jobs.
La troisième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Wait-Job dans chacune des sessions PSSession de $s. La commande Wait-Job détermine si toutes les commandes se sont terminées dans les 30 secondes. Elle utilise le paramètre Timeout avec une valeur de 30 (secondes) pour établir le délai d'attente maximal et enregistre les résultats de la commande dans la variable $done.
Dans ce cas, après 30 secondes, seule la commande exécutée sur l'ordinateur Server02 est terminée. Wait-Job met un terme à l'attente, affiche l'invite de commandes et retourne l'objet qui représente la tâche terminée.
La variable $done contient un objet de traitement qui représente la tâche qui s'est exécutée sur Server02.
Exemple 5
C:\PS>wait-job -id 1,2,5 -any Description ----------- Cette commande identifie trois tâches par leurs ID et attend qu'une d'elles se termine. L'invite de commandes réapparaît lorsque la première tâche se termine.
Exemple 6
C:\PS>wait-job -name DailyLog -timeout 120 Description ----------- Cette commande attend pendant 120 secondes (deux minutes) que la tâche DailyLog se termine. Si la tâche ne se termine pas dans les deux minutes suivantes, l'invite de commandes réapparaît quand même et la tâche continue de s'exécuter en arrière-plan.
Exemple 7
C:\PS>wait-job -name Job3 Description ----------- Cette commande Wait-Job utilise le nom de tâche pour identifier la tâche à attendre.
Exemple 8
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
Description
-----------
Cet exemple montre comment utiliser l'applet de commande Wait-Job avec des tâches démarrées sur l'ordinateur local à l'aide de l'applet de commande Start-Job.
Ces commandes démarrent une tâche qui obtient les fichiers de script Windows PowerShell qui ont été ajoutés ou mis à jour la semaine précédente.
La première commande utilise l'applet de commande Start-Job pour démarrer une tâche en arrière-plan sur l'ordinateur local. La tâche exécute une commande Get-ChildItem qui obtient tous les fichiers ayant une extension de nom de fichier « .ps1 » qui ont été ajoutés ou mis à jour la semaine précédente.
La troisième commande utilise l'applet de commande Wait-Job pour attendre que la tâche soit terminée. Lorsque la tâche se termine, la commande affiche l'objet de traitement qui contient des informations sur la tâche.
Exemple 9
C:\PS>$s = new-pssession Server01, Server02, Server03
C:\PS> $j = invoke-command -session $s -scriptblock {get-process} -asjob
C:\PS> $j | wait-job
Description
-----------
Cet exemple montre comment utiliser l'applet de commande Wait-Job avec des tâches démarrées sur des ordinateurs distants à l'aide du paramètre AsJob de l'applet de commande Invoke-Command. Lorsque AsJob est utilisée, la tâche est créée sur l'ordinateur local et les résultats sont retournés automatiquement à l'ordinateur local, même si la tâche s'exécute sur les ordinateurs distants.
Cet exemple utilise Wait-Job pour déterminer si une commande Get-Process qui s'exécute dans les sessions sur trois ordinateurs distants est terminée.
La première commande crée des sessions PSSession sur trois ordinateurs et les stocke dans la variable $s.
La deuxième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Get-Process dans chacune des trois sessions PSSession dans $s. Elle utilise le paramètre AsJob pour exécuter la commande de manière asynchrone en tant que tâche en arrière-plan. La commande retourne un objet de traitement, comme les tâches démarrées à l'aide de Start-Job, et l'objet de traitement est stocké dans la variable $j.
La troisième commande utilise un opérateur de pipeline (|) pour envoyer l'objet de traitement de $j à l'applet de commande Wait-Job. Remarquez qu'une commande Invoke-Command n'est pas obligatoire dans ce cas, parce que la tâche réside sur l'ordinateur local.
Exemple 10
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 Description ----------- Cette commande attend la tâche dont la valeur d'ID est 1.
Voir aussi