Wait-Job

Référence

Module:: Microsoft.PowerShell.Core

Supprime l’invite de commandes jusqu’à ce que l’un ou l’ensemble des travaux en arrière-plan PowerShell exécutés dans la session soient terminés.

Syntax

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

Wait-Job
    [-Job] <Job[]>
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [<CommonParameters>]

Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-Name] <String[]>
    [<CommonParameters>]

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

Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-State] <JobState>
    [<CommonParameters>]

Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-Filter] <Hashtable>
    [<CommonParameters>]

Description

L’applet Wait-Job de commande attend que les travaux en arrière-plan PowerShell se terminent avant d’afficher l’invite de commandes. Vous pouvez attendre la fin d'une tâche en arrière-plan donnée ou de toutes les tâches en arrière-plan, et vous pouvez définir un délai d'attente maximal pour la tâche.

Lorsque les commandes du travail sont terminées, Wait-Job affiche l’invite de commandes et retourne un objet de travail afin que vous puissiez le diriger vers une autre commande.

Vous pouvez utiliser Wait-Job l’applet de commande pour attendre les travaux en arrière-plan, tels que ceux qui ont été démarrés à l’aide de l’applet Start-Job de commande ou du paramètre AsJob de l’applet Invoke-Command de commande. Pour plus d'informations sur les tâches en arrière-plan Windows PowerShell, consultez about_Jobs.

À compter de Windows PowerShell 3.0, l’applet Wait-Job de commande attend également les types de travaux personnalisés, tels que les travaux de flux de travail et les instances des travaux planifiés. Pour activer Wait-Job l’attente des travaux d’un type particulier, importez le module qui prend en charge le type de travail personnalisé dans la session avant d’exécuter l’applet Get-Job de commande, soit à l’aide de l’applet de commande, soit à l’aide de l’applet Import-Module de commande, soit en utilisant ou en obtenant une applet de commande dans le module. Pour plus d'informations sur un type de tâche personnalisé particulier, consultez la documentation sur la fonctionnalité de type de tâche personnalisé.

Exemples

Exemple 1 : Attendre tous les travaux

Get-Job | Wait-Job

Cette commande attend que tous les travaux en arrière-plan s’exécutant dans la session se terminent.

Exemple 2 : Attendre le démarrage des travaux sur les ordinateurs distants à l’aide de Start-Job

$s = New-PSSession Server01, Server02, Server03
Invoke-Command -Session $s -ScriptBlock {Start-Job -Name Date1 -ScriptBlock {Get-Date}}
$done = Invoke-Command -Session $s -Command {Wait-Job -Name Date1}
$done.Count

3

Cet exemple montre comment utiliser l’applet Wait-Job de commande avec des travaux démarrés sur des ordinateurs distants à l’aide de l’applet de Start-Job commande. Les deux Start-Job et Wait-Job les commandes sont envoyées à l’ordinateur distant à l’aide de l’applet de Invoke-Command commande.

Cet exemple utilise Wait-Job pour déterminer si une Get-Date commande s’exécutant en tant que travail 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 les stocke dans la $s variable.

La deuxième commande utilise Invoke-Command pour s’exécuter Start-Job dans chacune des trois sessions dans $s. Tous les travaux sont nommés Date1.

La troisième commande utilise Invoke-Command pour exécuter Wait-Job. Cette commande attend que les travaux Date1 sur chaque ordinateur se terminent. Il stocke la collection obtenue (tableau) d’objets de travail dans la $done variable.

La quatrième commande utilise la propriété Count du tableau d’objets de travail dans la $done variable pour déterminer le nombre de travaux terminés.

Exemple 3 : Déterminer quand le premier travail en arrière-plan se termine

$s = New-PSSession (Get-Content Machines.txt)
$c = 'Get-EventLog -LogName System | where {$_.EntryType -eq "error" --and $_.Source -eq "LSASRV"} | Out-File Errors.txt'
Invoke-Command -Session $s -ScriptBlock {Start-Job -ScriptBlock {$Using:c}
Invoke-Command -Session $s -ScriptBlock {Wait-Job -Any}

Cet exemple utilise le paramètre Any de Wait-Job déterminer quand les premiers travaux en arrière-plan exécutés dans la session active sont terminés. Elle montre également comment utiliser l’applet Wait-Job de commande pour attendre que les travaux distants se terminent.

La première commande crée une PSSession sur chacun des ordinateurs répertoriés dans le fichier Machines.txt et stocke les objets PSSession dans la $s variable. La commande utilise l’applet Get-Content de commande pour obtenir le contenu du fichier. La Get-Content commande est placée entre parenthèses pour vous assurer qu’elle s’exécute avant la New-PSSession commande.

La deuxième commande stocke une Get-EventLog chaîne de commande, entre guillemets, dans la $c variable.

La troisième commande utilise Invoke-Command l’applet de commande pour s’exécuter Start-Job dans chacune des sessions dans $s. La Start-Job commande démarre un travail en arrière-plan qui exécute la Get-EventLog commande dans la $c variable.

La commande utilise le modificateur d’étendue Using pour indiquer que la $c variable a été définie sur l’ordinateur local. Le modificateur d'étendue Using a été introduit pour la première fois dans Windows PowerShell 3.0. Pour plus d’informations sur l’utilisation du modificateur d’étendue, consultez about_Remote_Variables.

La quatrième commande utilise Invoke-Command pour exécuter une Wait-Job commande dans les sessions. Il utilise le paramètre Any pour attendre que le premier travail sur les ordinateurs distants soit terminé.

Exemple 4 : Définir un temps d’attente pour les travaux sur des ordinateurs distants

$s = New-PSSession Server01, Server02, Server03
$jobs = Invoke-Command -Session $s -ScriptBlock {Start-Job -ScriptBlock {Get-Date}}
$done = Invoke-Command -Session $s -ScriptBlock {Wait-Job -Timeout 30}

Cet exemple montre comment utiliser le paramètre Timeout pour Wait-Job définir une durée d’attente maximale pour les travaux exécutés sur des ordinateurs distants.

La première commande crée une PSSession sur chacun des trois ordinateurs distants (Server01, Server02 et Server03), puis stocke les objets PSSession dans la $s variable.

La deuxième commande utilise Invoke-Command pour s’exécuter Start-Job dans chacun des objets PSSession dans $s. Il stocke les objets de travail résultants dans la $jobs variable.

La troisième commande utilise Invoke-Command pour s’exécuter Wait-Job dans chacune des sessions dans $s. La Wait-Job commande détermine si toutes les commandes ont été effectuées dans les 30 secondes. Il utilise le paramètre Timeout avec une valeur de 30 pour établir le temps d’attente maximal, puis stocke les résultats de la commande dans la $done variable.

Dans ce cas, après 30 secondes, seule la commande sur l'ordinateur Server02 s'est terminée. Wait-Job termine l’attente, affiche l’invite de commandes et retourne l’objet qui représente le travail terminé.

La $done variable contient un objet de travail qui représente le travail exécuté sur Server02.

Exemple 5 : Attendre la fin de l’un de plusieurs travaux

Wait-Job -id 1,2,5 -Any

Cette commande identifie trois travaux par leurs ID et attend que l’un d’eux soit terminé. L’invite de commandes retourne une fois le premier travail terminé.

Exemple 6 : Attendre une période, puis autoriser le travail à continuer en arrière-plan

Wait-Job -Name "DailyLog" -Timeout 120

Cette commande attend 120 secondes (deux minutes) pour que la tâche DailyLog se termine. Si le travail ne se termine pas au cours des deux prochaines minutes, l’invite de commandes retourne de toute façon, et le travail continue à s’exécuter en arrière-plan.

Exemple 7 : Attendre un travail par nom

Wait-Job -Name "Job3"

Cette commande utilise le nom du travail pour identifier le travail pour lequel attendre.

Exemple 8 : Attendre des travaux sur un ordinateur local démarré avec Start-Job

$j = Start-Job -ScriptBlock {Get-ChildItem *.ps1| where {$_lastwritetime -gt ((Get-Date) - (New-TimeSpan -Days 7))}}
$j | Wait-Job

Cet exemple montre comment utiliser l’applet Wait-Job de commande avec des travaux démarrés sur l’ordinateur local à l’aide Start-Jobde .

Ces commandes démarrent une tâche qui obtient les fichiers de script Windows PowerShell qui ont été ajoutés ou mis à jour au cours de la semaine précédente.

La première commande utilise Start-Job pour démarrer un travail en arrière-plan sur l’ordinateur local. Le travail exécute une Get-ChildItem commande qui obtient tous les fichiers qui ont une extension de nom de fichier .ps1 qui ont été ajoutés ou mis à jour la semaine dernière.

La troisième commande utilise Wait-Job pour attendre que le travail soit terminé. Une fois le travail terminé, la commande affiche l’objet de travail, qui contient des informations sur le travail.

Exemple 9 : Attendre que les travaux ont démarrés sur des ordinateurs distants à l’aide de Invoke-Command

$s = New-PSSession Server01, Server02, Server03
$j = Invoke-Command -Session $s -ScriptBlock {Get-Process} -AsJob
$j | Wait-Job

Cet exemple montre comment utiliser Wait-Job des travaux démarrés sur des ordinateurs distants à l’aide du paramètre AsJob de Invoke-Command. Lorsque vous utilisez AsJob, le travail est créé sur l’ordinateur local et les résultats sont automatiquement retournés à l’ordinateur local, même si le travail s’exécute sur les ordinateurs distants.

Cet exemple utilise Wait-Job pour déterminer si une Get-Process commande s’exécutant dans les sessions sur trois ordinateurs distants est terminée.

La première commande crée des objets PSSession sur trois ordinateurs et les stocke dans la $s variable.

La deuxième commande utilise Invoke-Command pour s’exécuter Get-Process dans chacune des trois sessions dans $s. La commande utilise le paramètre AsJob pour exécuter la commande de manière asynchrone en tant que travail en arrière-plan. La commande retourne un objet de travail, tout comme les travaux démarrés à l’aide Start-Job, et l’objet de travail est stocké dans la $j variable.

La troisième commande utilise un opérateur de pipeline (|) pour envoyer l’objet de travail à $j l’applet Wait-Job de commande. Une Invoke-Command commande n’est pas requise dans ce cas, car le travail réside sur l’ordinateur local.

Exemple 10 : Attendre un travail qui a un ID

Get-Job

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

Wait-Job -Id 1

Cette commande attend la tâche dotée d'un ID de valeur 1.

Paramètres

-Any

Indique que cette applet de commande affiche l’invite de commandes et retourne l’objet de travail, lorsque tout travail se termine. Par défaut, Wait-Job attend que tous les travaux spécifiés soient terminés avant d’afficher l’invite.

Type:	SwitchParameter
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Filter

Spécifie une table de hachage des conditions. Cette applet de commande attend les travaux qui répondent à toutes les conditions de la table de hachage. Entrez une table de hachage où les clés sont les propriétés des travaux et les valeurs celles des propriétés des travaux.

Ce paramètre fonctionne uniquement sur les types de tâches personnalisées, tels que les tâches de workflow et les tâches planifiées. Elle ne fonctionne pas sur les travaux en arrière-plan standard, tels que ceux créés à l’aide de l’applet de Start-Job commande. Pour plus d'informations sur la prise en charge de ce paramètre, consultez la rubrique d'aide relative au type de tâche.

Ce paramètre a été introduit dans Windows PowerShell 3.0.

Type:	Hashtable
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Force

Indique que cette applet de commande continue d’attendre les travaux dans l’état suspendu ou déconnecté. Par défaut, Wait-Job retourne ou termine l’attente, lorsque les travaux se trouvent dans l’un des états suivants :

Completed
Échec
Arrêté
Interrompu
Déconnecté

Ce paramètre a été introduit dans Windows PowerShell 3.0.

Type:	SwitchParameter
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Id

Spécifie un tableau d’ID de travaux pour lesquels cette applet de commande attend.

L’ID est un entier qui identifie de manière unique le travail dans la session active. Il est plus facile de mémoriser et de taper que l’ID d’instance, mais il est unique uniquement dans la session actuelle. Vous pouvez taper un ou plusieurs ID séparés par des virgules. Pour rechercher l’ID d’un travail, tapez Get-Job.

Type:	Int32[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-InstanceId

Spécifie un tableau d’ID d’instance de travaux pour lesquels cette applet de commande attend. Par défaut, il s'agit de toutes les tâches.

Un ID d'instance est un GUID qui identifie de façon unique la tâche sur l'ordinateur. Pour rechercher l’ID d’instance d’un travail, utilisez Get-Job.

Type:	Guid[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Job

Spécifie les travaux pour lesquels cette applet de commande attend. Entrez une variable qui contient les objets de traitement ou une commande permettant d'obtenir ces objets de traitement. Vous pouvez également utiliser un opérateur de pipeline pour envoyer des objets de travail à l’applet de Wait-Job commande. Par défaut, Wait-Job attend tous les travaux créés dans la session active.

Type:	Job[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Name

Spécifie les noms convivial des travaux pour lesquels cette applet de commande attend.

Type:	String[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-State

Spécifie un état de travail. Cette applet de commande attend uniquement les travaux dans l’état spécifié. Les valeurs valides pour ce paramètre sont :

NotStarted
Exécution en cours
Completed
Échec
Arrêté
Bloqué
Interrompu
Déconnecté
Suspension
En cours d’arrêt

Pour plus d’informations sur les états de travail, consultez l’énumération JobState.

Type:	JobState
Accepted values:	NotStarted, Running, Completed, Failed, Stopped, Blocked, Suspended, Disconnected, Suspending, Stopping, AtBreakpoint
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Timeout

Spécifie la durée d’attente maximale pour chaque travail en arrière-plan, en secondes. La valeur par défaut, -1, indique que l’applet de commande attend que le travail se termine. Le minutage commence lorsque vous envoyez la Wait-Job commande, et non la Start-Job commande.

Si ce délai est dépassé, 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. La commande n’affiche aucun message d’erreur.

Type:	Int32
Aliases:	TimeoutSec
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

Entrées

System.Management.Automation.RemotingJob

Vous pouvez diriger un objet de travail vers cette applet de commande.

Sorties

System.Management.Automation.PSRemotingJob

Cette applet de commande retourne des objets de travail qui représentent les travaux terminés. Si l’attente se termine parce que la valeur du paramètre Timeout est dépassée, Wait-Job ne retourne aucun objet.

Notes

Par défaut, Wait-Job retourne ou termine l’attente, lorsque les travaux se trouvent dans l’un des états suivants :

Completed
Échec
Arrêté
Interrompu
Déconnecté Pour Wait-Job continuer à attendre les travaux suspendus et déconnectés, utilisez le paramètre Force .