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>]

El cmdlet Wait-Job espera a que los trabajos en segundo plano de Windows PowerShell finalicen antes de que muestre el símbolo del sistema. Puede esperar hasta que se complete cualquier trabajo en segundo plano o hasta que se completen todos los trabajos en segundo plano y puede establecer un tiempo de espera máximo para el trabajo.

Una vez completados los comandos del trabajo, Wait-Job muestra el símbolo del sistema y devuelve un objeto de trabajo para que pueda canalizarlo a otro comando.

Puede usar cmdlet Wait-Job para esperar trabajos en segundo plano, como los que se iniciaron mediante el cmdlet Start-Job o el parámetro AsJob del cmdlet Invoke-Command. Para obtener más información sobre los trabajos en segundo plano de Windows PowerShell, consulte about_Jobs.

A partir de Windows PowerShell 3.0, el cmdlet Wait-Job también espera tipos de trabajo personalizados, como trabajos de flujo de trabajo e instancias de trabajos programados. Para habilitar Wait-Job esperar trabajos de un tipo determinado, importe el módulo que admite el tipo de trabajo personalizado en la sesión antes de ejecutar el cmdlet Get-Job, ya sea mediante el cmdlet Import-Module o mediante o obteniendo un cmdlet en el módulo. Para obtener información sobre un tipo de trabajo personalizado determinado, consulte la documentación de la característica de tipo de trabajo personalizado.

PS C:\> Get-Job | Wait-Job

Este comando espera a que finalicen todos los trabajos en segundo plano que se ejecutan en la sesión.

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

En este ejemplo se muestra cómo usar el cmdlet Wait-Job con trabajos iniciados en equipos remotos mediante el cmdlet Start-Job. Tanto start-job como comandos Wait-Job se envían al equipo remoto mediante el cmdlet Invoke-Command de .

En este ejemplo se usa Wait-Job para determinar si se ha finalizado un comando de Get-Date que se ejecuta como un trabajo en segundo plano en tres equipos diferentes.

El primer comando crea una sesión de Windows PowerShell (PSSession) en cada uno de los tres equipos remotos y los almacena en la variable $s.

El segundo comando usa Invoke-Command para ejecutar start-Job en cada una de las tres sesiones de $s. Todos los trabajos se denominan Date1.

El tercer comando usa Invoke-Command para ejecutar Wait-Job. Este comando espera a que finalicen los trabajos date1 de cada equipo. Almacena la colección resultante (matriz) de objetos de trabajo en la variable $done.

El cuarto comando usa la propiedad Count de la matriz de objetos de trabajo de la variable $done para determinar cuántos de los trabajos han finalizado.

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

En este ejemplo se usa el parámetro Any de Wait-Job para determinar cuándo se completan los primeros trabajos en segundo plano que se ejecutan en la sesión actual. También se muestra cómo usar el cmdlet wait-job de para esperar a que finalicen los trabajos remotos.

El primer comando crea un psSession de en cada uno de los equipos enumerados en el archivo Machines.txt y almacena los objetos PSSession en la variable $s. El comando usa el cmdlet Get-Content para obtener el contenido del archivo. El comando Get-Content se incluye entre paréntesis para asegurarse de que se ejecuta antes del comando New-PSSession.

El segundo comando almacena una cadena de comandos Get-EventLog, entre comillas, en la variable $c.

El tercer comando usa Invoke-Command cmdlet para ejecutar Start-Job en cada una de las sesiones de $s. El comando start-job inicia un trabajo en segundo plano que ejecuta el comando Get-EventLog en la variable $c.

El comando usa el modificador Using scope para indicar que la variable $c se definió en el equipo local. El modificador de ámbito Using se introduce en Windows PowerShell 3.0. Para obtener más información sobre el modificador de ámbito , vea about_Remote_Variables ().

El cuarto comando usa Invoke-Command para ejecutar un comando Wait-Job en las sesiones. Usa el parámetro Any para esperar hasta que se complete el primer trabajo en los equipos remotos.

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

En este ejemplo se muestra cómo usar el parámetro timeout de Wait-Job para establecer un tiempo de espera máximo para los trabajos que se ejecutan en equipos remotos.

El primer comando crea un de PSSession en cada uno de los tres equipos remotos (Server01, Server02 y Server03) y, a continuación, almacena los objetos PSSession en la variable $s.

El segundo comando usa Invoke-Command para ejecutar Start-Job en cada uno de los objetos psSession de en $s. Almacena los objetos de trabajo resultantes en la variable $jobs.

El tercer comando usa Invoke-Command para ejecutar Wait-Job en cada una de las sesiones de $s. El comando Wait-Job determina si todos los comandos se han completado en un plazo de 30 segundos. Usa el parámetro Timeout con un valor de 30 para establecer el tiempo de espera máximo y, a continuación, almacena los resultados del comando en la variable $done.

En este caso, después de 30 segundos, solo se ha completo el comando del equipo Server02. Wait-Job finaliza la espera, muestra el símbolo del sistema y devuelve el objeto que representa el trabajo que se completó.

La variable $done contiene un objeto de trabajo que representa el trabajo que se ejecutó en Server02.

PS C:\> Wait-Job -id 1,2,5 -Any

Este comando identifica tres trabajos por sus identificadores y espera hasta que se complete cualquiera de ellos. El símbolo del sistema devuelve cuando finaliza el primer trabajo.

PS C:\> Wait-Job -Name "DailyLog" -Timeout 120

Este comando espera 120 segundos (dos minutos) para que finalice el trabajo DailyLog. Si el trabajo no finaliza en los próximos dos minutos, el símbolo del sistema devuelve de todos modos y el trabajo continúa ejecutándose en segundo plano.

PS C:\> Wait-Job -Name "Job3"

Este comando usa el nombre del trabajo para identificar el trabajo que se va a esperar.

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

En este ejemplo se muestra cómo usar el cmdlet Wait-Job con trabajos iniciados en el equipo local mediante Start-Job.

Estos comandos inician un trabajo que obtiene los archivos de script de Windows PowerShell que se agregaron o actualizaron en la semana pasada.

El primer comando usa Start-Job para iniciar un trabajo en segundo plano en el equipo local. El trabajo ejecuta un comando Get-ChildItem que obtiene todos los archivos que tienen una extensión de nombre de archivo .ps1 que se agregaron o actualizaron en la semana pasada.

El tercer comando usa wait-Job para esperar hasta que se complete el trabajo. Cuando finalice el trabajo, el comando muestra el objeto de trabajo, que contiene información sobre el trabajo.

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

En este ejemplo se muestra cómo usar Wait-Job con trabajos iniciados en equipos remotos mediante el parámetro de AsJob de Invoke-Command. Al usar AsJob, el trabajo se crea en el equipo local y los resultados se devuelven automáticamente al equipo local, aunque el trabajo se ejecute en los equipos remotos.

En este ejemplo se usa wait-Job para determinar si se completa un comando de Get-Process que se ejecuta en las sesiones de tres equipos remotos.

El primer comando crea objetos PSSession en tres equipos y los almacena en la variable $s.

El segundo comando usa Invoke-Command para ejecutar Get-Process en cada una de las tres sesiones de $s. El comando usa el parámetro AsJob para ejecutar el comando de forma asincrónica como un trabajo en segundo plano. El comando devuelve un objeto de trabajo, al igual que los trabajos iniciados mediante Start-Joby el objeto de trabajo se almacena en la variable $j.

El tercer comando usa un operador de canalización (|) para enviar el objeto de trabajo en $j al cmdlet Wait-Job. En este caso, no se requiere un comando Invoke- Command, ya que el trabajo reside en el equipo local.

PS C:\> Get-Job

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

PS C:\> Wait-Job -Id 1

Este comando espera al trabajo con un valor de identificador 1.

Este cmdlet admite los parámetros comunes: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction y -WarningVariable. Para obtener más información, vea about_CommonParameters.

Puede canalizar un objeto de trabajo a este cmdlet.

Este cmdlet devuelve objetos de trabajo que representan los trabajos completados. Si finaliza la espera porque se supera el valor del parámetro Timeout, Wait-Job no devuelve ningún objeto.

• De forma predeterminada, Wait-Job devuelve o finaliza la espera, cuando los trabajos se encuentran en uno de los estados siguientes:

• Completado
• Fracasado
• Detenido
• Suspendido
• Desconectado Para dirigir Wait-Job para continuar esperando trabajos suspendidos y desconectados, use el parámetro Force .