Wait-Job

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

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

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

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

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

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

L’applet de commande Wait-Job attend qu’un travail soit dans un état d’arrêt avant de reprendre son exécution. Les états de fin sont les suivants :

• Terminé
• Échec
• Arrêté
• Interrompu
• Déconnecté

Vous pouvez attendre qu’un travail spécifié, ou que tous les travaux soient en état d’arrêt. Vous pouvez également définir un délai d'attente maximal pour le travail à l'aide du paramètre Timeout, ou utiliser le paramètre Force pour attendre un travail dans les états Suspended ou Disconnected.

Lorsque les commandes du travail sont terminées, Wait-Job retourne un objet de travail et poursuit l’exécution.

Vous pouvez utiliser l’applet de commande Wait-Job pour attendre les travaux commencés à l’aide de l’applet de commande Start-Job ou du paramètre AsJob de l’applet de commande Invoke-Command. Pour plus d’informations sur les emplois, consultez about_Jobs.

À compter de Windows PowerShell 3.0, l’applet de commande Wait-Job attend également les types de travaux personnalisés, tels que les travaux de flux de travail et les instances de travaux planifiés. Pour permettre à Wait-Job d’attendre 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 de commande Get-Job, soit à l’aide de l’applet de commande Import-Module, soit en utilisant ou en obtenant une applet de commande dans le module. Pour plus d’informations sur un type de travail personnalisé particulier, consultez la documentation de la fonctionnalité de type de travail personnalisé.

Get-Job | Wait-Job

Cette commande attend que tous les travaux en cours d’exécution dans la session se terminent.

$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 de commande Wait-Job avec les travaux démarrés sur des ordinateurs distants à l’aide de l’applet de commande Start-Job. Les commandes Start-Job et Wait-Job sont envoyées à 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 exécutée en tant que travail 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 variable $s.

La deuxième commande utilise Invoke-Command pour exécuter Start-Job dans chacune des trois sessions de $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 tâches Date1 sur chaque ordinateur se terminent. Il stocke la collection résultante (tableau) d’objets tâche dans la variable $done.

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

$s = New-PSSession -ComputerName (Get-Content -Path .\Machines.txt)
$c = 'Get-EventLog -LogName System | Where-Object {$PSItem.EntryType -eq "error" --and $PSItem.Source -eq "LSASRV"} | Out-File -FilePath 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 pour déterminer quand le premier de nombreux travaux en cours d’exécution dans la session en cours est en cours de terminaison. Il montre également comment utiliser l’applet de commande Wait-Job pour attendre que les travaux distants se terminent.

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

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

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

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

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

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

Cet exemple montre comment utiliser le paramètre Timeout de Wait-Job pour définir un délai d’attente maximal 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 variable $s.

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

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

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

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

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

Cette commande identifie trois travaux par leurs ID et attend que l’un d’eux soit dans un état d’arrêt. L'exécution continue après que la première tâche est terminée.

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’exécution se poursuit et le travail continue à s’exécuter en arrière-plan.

Wait-Job -Name "Job3"

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

$j = Start-Job -ScriptBlock {Get-ChildItem -Filter *.ps1 | Where-Object {$PSItem.LastWriteTime -gt ((Get-Date) - (New-TimeSpan -Days 7))}}
$j | Wait-Job

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

Ces commandes démarrent un travail qui obtient les fichiers de script Windows PowerShell qui ont été ajoutés ou mis à jour la semaine dernière.

La première commande utilise Start-Job pour démarrer un travail sur l’ordinateur local. Le travail exécute une commande Get-ChildItem 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 en état d’arrêt. Une fois le travail terminé, la commande affiche l’objet de travail, qui contient des informations sur le travail.

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

Cet exemple montre comment utiliser Wait-Job avec les 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 commande Get-Process en cours d’exécution dans les sessions sur trois ordinateurs distants est dans un état de fin.

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

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

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

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.

Cette applet de commande prend en charge les paramètres courants : -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction et -WarningVariable. Pour plus d’informations, consultez about_CommonParameters.

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

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

PowerShell inclut les alias suivants pour Wait-Job:

• Toutes les plateformes :
  • wjb

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

• Terminé
• Échec
• Arrêté
• Interrompu
• Déconnecté

Pour diriger Wait-Job pour continuer à attendre les travaux suspendus et déconnectés, utilisez le paramètre Force.