Powershell waitforexit example

exemplo Powershell waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
Aguarde até que o processo saia usando powershell.
Eu tinha um pequeno programa em F # (semelhante ao C #), que recebe processos por nome, depois filtra o particular por seu caminho e espera que ele saia:
Mas este código funciona apenas no computador local. Agora quero alcançar a mesma funcionalidade no computador remoto.
Então é por isso que escolho o PowerShell (eu sou completamente novo para ele).
É possível filtrar o processo por seu caminho e esperar que ele saia usando uma linha no powershell? Caso contrário, talvez você possa fornecer uma solução mais longa?
Como eu executarei essa linha no computador remoto. Eu já tenho uma idéia. Tudo o que preciso é apenas essa linha mágica.
EDIT: Na verdade, essa linha deve funcionar na máquina local, porque vou passá-la usando o msdeploy, que a executa na máquina remota como um comando local.
Passou algum tempo jogando com powershell e finalmente consegui o que queria:

exemplo Powershell waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
Powershell Start Process, Wait with Timeout, Kill e Get Exit Code.
Eu quero executar repetidamente um programa em um loop.
Às vezes, o programa falha, então eu quero matá-lo para que a próxima iteração possa começar corretamente. Eu determino isso por tempo limite.
Tenho o tempo limite de trabalho, mas não consigo obter o Código de Saída do programa, que também preciso determinar o resultado.
Antes, eu não esperava com o tempo limite, mas apenas usava - wait no Start-Process, mas isso fazia o script travar se o programa iniciado travasse. Com esta configuração, eu poderia obter corretamente o código de saída.
Estou executando a partir do ISE.
Inicie um processo Aguarde que ele execute e termine de forma ordenada Mate-o se ele for interrompido (por exemplo, o tempo limite de hits) obtenha o código de saída do processo.

exemplo Powershell waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
Como dizer ao PowerShell para esperar que cada comando termine antes de iniciar o próximo?
Eu tenho um script do PowerShell 1.0 para apenas abrir um monte de aplicativos. A primeira é uma máquina virtual e as outras são aplicações de desenvolvimento. Eu quero que a máquina virtual termine a inicialização antes que o restante dos aplicativos seja aberto.
Em bash, eu poderia simplesmente dizer "cmd1 & amp; amp; cmd2"
Isto é o que eu tenho.
Normalmente, para comandos internos, o PowerShell aguarda antes de iniciar o próximo comando. Uma exceção a esta regra é o EXE baseado no subsistema Windows externo. O primeiro truque é o pipeline para Out-Null, assim:
O PowerShell aguardará até que o processo Notepad. exe tenha sido encerrado antes de continuar. Isso é bacana, mas um pouco sutil de ler o código. Você também pode usar o Start-Process com o parâmetro - Wait:
Se você estiver usando a versão PowerShell Community Extensions, é:
Outra opção no PowerShell 2.0 é usar um trabalho em segundo plano:
Além de usar o Start-Process-Wait, a saída de um executável será executada pela Powershell. Dependendo da necessidade, tipicamente eu toco para Out-Null, Out-Default, Out-String ou Out-String - Stream. Aqui está uma longa lista de algumas outras opções de saída.
Sinto falta das operadoras de estilo CMD / Bash que você referenciou (& amp ;, & amp; & amp ;, ||). Parece que temos que ser mais detalhados com Powershell.
Basta usar "Wait-process":
Se você usar Start-Process & lt; path to exe & gt; - NãoNewWindow - Espere.
Você também pode usar a opção - PassThru para ecoar a saída.
Alguns programas não podem processar o fluxo de saída muito bem, usando o pipe para Out-Null pode não bloqueá-lo.
E Start-Process precisa da opção - ArgumentList para passar argumentos, não é tão conveniente.
Há também outra abordagem.
Incluindo a opção - NoNewWindow me dá um erro: Start-Process: Este comando não pode ser executado devido ao erro: Acesso negado.

Arquivo.
2015 (5)
2013 (11)
2011 (11)
2009 (30)
2007 (34)
2005 (53)
2003 (23)
Retornando um código de saída de um script do PowerShell.
Retornar um código de saída de um script do PowerShell parece fácil ... mas não é tão óbvio. Nesta publicação do blog, vou mostrar-lhe uma abordagem que funciona para scripts do PowerShell que podem ser chamados dos scripts do PowerShell e do lote, onde o comando a ser executado pode ser especificado em uma string, executar em seu próprio contexto e sempre retornar o erro correto código.
Abaixo está um tipo de transcrição dos passos que tomei para chegar a uma abordagem que funciona para mim. É uma transcrição dos passos que tomei, pois as conclusões apenas saltam até o fim.
Em muitas postagens de blog, você pode ler sobre como chamar um script do PowerShell que você chama de um script em lote e como retornar um código de erro. Isso se resume ao seguinte:
Write-Host "Sair com o código 12345 & quot;
Echo From Cmd. exe: Exit. ps1 saiu com o código de saída% errorlevel%
Executar c: \ temp \ testexit. cmd resulta na seguinte saída:
Sair com o código 12345.
De Cmd. exe: Exit. ps1 saiu com o código de saída 12345.
Mas agora queremos chamá-lo de outro script do PowerShell, executando o PowerShell:
PowerShell - NonInteractive - NoProfile - Command c: \ temp \ exit. ps1.
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
Executar c: \ temp \ testexit. ps1 resulta na seguinte saída:
Sair com o código 12345.
Do PowerShell: Exit. ps1 saiu com o código de saída 1.
Isso não é o que esperávamos ... O que aconteceu? Se o script simplesmente retornar, o código de saída é 0, caso contrário o código de saída é 1, mesmo se você sair com um código de saída !?
Mas e se chamarmos o script diretamente, em vez do comando PowerShell?
Nós mudamos exit. ps1 para:
Write-Host "Global variable value: $ globalvariable & quot;
Write-Host "Sair com o código 12345 & quot;
E mudamos testexit. ps1 para:
$ global: globalvariable = "My global variable value & quot;
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
Executar c: \ temp \ testexit. ps1 resulta na seguinte saída:
Valor da variável global: o valor da minha variável global.
Sair com o código 12345.
Do PowerShell: Exit. ps1 saiu com o código de saída 12345.
Isto é o que queríamos! Mas agora estamos executando o script exit. ps1 no contexto do script testexit. ps1, a variável definida globalmente $ globalvariable ainda é conhecida. Isso não é o que queremos. Queremos executá-lo é isolamento.
Alteramos c: \ temp \ testexit. ps1 para:
$ global: globalvariable = "My global variable value & quot;
PowerShell - NonInteractive - NoProfile - Command c: \ temp \ exit. ps1.
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
A execução de c: \ temp \ testexit. ps1 resulta na seguinte saída:
Valor variável global:
Sair com o código 12345.
Do PowerShell: Exit. ps1 saiu com o código de saída 1.
Não executamos exit. ps1 no contexto de testexit. ps1, o que é bom. Mas como podemos alcançar o Santo Graal:
Escreva um script do PowerShell que pode ser executado a partir de scripts em lote e do PowerShell. Isso retorna um código de erro específico que pode ser especificado como uma string. Pode ser executado tanto no contexto de um script de PowerShell de chamada E (através de uma chamada para o PowerShell) em sua própria execução espaço.
Alteramos c: \ temp \ testexit. ps1 para:
$ global: globalvariable = "My global variable value & quot;
PowerShell - NonInteractive - NoProfile - Command & # 160;
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
Esta é a mesma abordagem que quando chamamos isso do script em lote. Executar c: \ temp \ testexit. ps1 resulta na seguinte saída:
Valor variável global:
Sair com o código 12345.
Do PowerShell: Exit. ps1 saiu com o código de saída 12345.
Isso é próximo. Mas queremos poder especificar o comando a ser executado como seqüência de caracteres, por exemplo:
$ comando = & quot; c: \ temp \ exit. ps1-param1 x - param2 y & quot;
Alteramos c: \ temp \ exit. ps1 para: (suporte para variáveis, teste se em seu próprio contexto)
param ($ param1, $ param2)
Write-Host "param1 = $ param1; param2 = $ param2 & quot;
Write-Host "Global variable value: $ globalvariable & quot;
Write-Host "Sair com o código 12345 & quot;
Se mudarmos c: \ temp \ testexit. ps1 para:
$ global: globalvariable = "My global variable value & quot;
$ comando = & quot; c: \ temp \ exit. ps1-param1 x - param2 y & quot;
Comando Invoke-Expression - Command $.
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
Recebemos um bom código de saída, mas ainda estamos executando no contexto de testexit. ps1.
Se usarmos o mesmo truque que na chamada de um script em lote, que funcionou antes?
Alteramos c: \ temp \ testexit. ps1 para:
$ global: globalvariable = "My global variable value & quot;
$ command = & quot; c: \ temp \ exit. ps1 - param1 x - param2 y & quot;
PowerShell - NonInteractive - NoProfile - Command.
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
Executar c: \ temp \ testexit. ps1 resulta na seguinte saída:
Do PowerShell: Exit. ps1 saiu com o código de saída 0.
Ok, vamos usar o Invoke-Expression novamente. Alteramos c: \ temp \ testexit. ps1 para:
$ global: globalvariable = & quot; Valor da minha variável global & quot;
$ comando = & quot; c: \ temp \ exit. ps1-param1 x - param2 y & quot;
PowerShell - NãoInterativo - NoProfile - Command.
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
A execução de c: \ temp \ testexit. ps1 resulta na seguinte saída:
Não é possível vincular o argumento ao parâmetro 'Comando' porque é nulo.
Em: linha: 3 char: 10.
+ PowerShell & lt; & lt; & lt; & lt; & # 160; - Não Interativo - NoProfile - Command.
Do PowerShell: Exit. ps1 saiu com o código de saída 1.
Devemos voltar a executar o comando como uma string, portanto, não entre colchetes (em um bloco de script). Alteramos c: \ temp \ testexit. ps1 para:
$ global: globalvariable = "My global variable value & quot;
$ command = & quot; c: \ temp \ exit. ps1 - param1 x - param2 y & quot;
PowerShell - NonInterativo - NoProfile - Command $ command.
Write-Host "do PowerShell: Exit. ps1 saiu com o código de saída $ LastExitCode & quot;
A execução de c: \ temp \ testexit. ps1 resulta na seguinte saída:
Valor variável global:
Saindo com o código 12345.
Do PowerShell: Exit. ps1 saiu com o código de saída 1.
Ok, podemos executar o texto do comando especificado como se fosse um comando do PowerShell. Mas ainda temos o problema do código de saída, apenas 0 ou 1 são retornados.
Vamos tentar algo completamente diferente. Alteramos c: \ temp \ exit. ps1 para:
param ($ param1, $ param2)
Write-Host & quot; param1 = $ param1; param2 = $ param2 & quot;
Write-Host & quot; Valor da variável global: $ globalvariable & quot;
Write-Host "Sair com o código 12345 & quot;
ExitWithCode - exitcode 12345.
Write-Host "Depois de sair"
O que fazemos é especificar para o host o código de saída que gostaríamos de usar e, em seguida, saia, tudo na função de utilidade mais simples.
Executar c: \ temp \ testexit. ps1 resulta na seguinte saída:
Valor variável global:
Sair com o código 12345.
Do PowerShell: Exit. ps1 saiu com o código de saída 12345.
Ok, isso cumpre todos os nossos sonhos do santo Graal! Mas não podemos fazer a chamada do script em lote também mais simples?
Altere c: \ temp \ testexit. cmd para:
PowerShell - NonInteractive - NoProfile - Command & quot; c: \ temp \ exit. ps1 - param1 x - param2 y & quot;
Echo From Cmd. exe: Exit. ps1 saiu com o código de saída% errorlevel%
Executar c: \ temp \ testexit. cmd resulta na seguinte saída:
Valor variável global:
Sair com o código 12345.
De Cmd. exe: Exit. ps1 saiu com o código de saída 12345.
Isso é ainda mais simples! Agora podemos chamar o código PowerShell, sem a saída $ LastExitCode trick!
E agora as conclusões após essa longa e longa história, isso levou muito tempo para descobrir (e para ler para você):
Não use saída para retornar um valor do código PowerShell, mas use a seguinte função:
Script de chamada a partir do lote usando:
PowerShell - NonInterativo - NoProfile - Command $ command.
Invoke-Expression - Command $ command $ LastExitCode contém o código de saída.
9 Comentários.
Bom post, mas por que você não usou o interruptor de arquivo em vez do comutador de comando? Se você quiser apenas executar um script e estiver interessado em seu código de saída, isso me parece muito mais simples:
Com o arquivo, você não pode especificar nenhum argumento.
Na verdade, você pode especificar argumentos, pelo menos no v2 PowerShell.
Obrigado por compartilhar. Na função ExitWithCode, não pretenda "sair $ exitcode"?
Isso não funciona para mim (XP / PS1), na execução do lote, meu código de saída é 0, não importa o que eu configurei no script ps.
Em outras palavras, seja qual for o valor de $ exitcode para colocar em $ host. SetShouldExit ($ exitcode),% errorlevel% return 0 ou o que eu especifique para o comando exit, então "exit 358 & quot; Trabalha e me entrega o código de saída 358.
Postagem incrível. Pergunta rápida: não deveria ser uma das explicações na Conclusão sobre como chamá-la, incluindo o & # 39; & amp; & # 39; personagem para - Command?
Postagem altamente descritiva, adorei esse pouco. Haverá.
Olá! Eu só gostaria de lhe oferecer um grande favor para a sua excelente informação que você tem aqui neste post. Voltarei ao seu site mais cedo.

Gerenciando Processos no PowerShell.
Várias pessoas perguntaram recentemente sobre como gerenciar processos no PowerShell. Esta postagem no blog deve responder a uma série dessas questões.
Como se poderia esperar do & # 8220; shell & # 8221; parte do PowerShell, você não precisa fazer nada especial para iniciar um processo. Em uma linguagem de programação como o VBScript, você precisa fazer algo bastante complexo como:
Defina objWMIService = GetObject (& # 8220; winmgmts: & # 8221; _.
Set objStartup = objWMIService. Get (& # 8220; Win32_ProcessStartup & # 8221;)
Defina objConfig = objStartup. SpawnInstance_.
Set objProcess = GetObject (& # 8220; winmgmts: root \ cimv2: Win32_Process & # 8221;)
objProcess. Create & # 8220; Notepad. exe & # 8221 ;, Null, objConfig, intProcessID.
mas em conchas (PowerShell, cmd. exe, bash, etc.), você pode simplesmente iniciar um programa como bloco de notas simplesmente digitando & # 8220; notepad & # 8221; como mostrado.
Agora, você notará que quando você faz isso, o shell retorna imediatamente e solicita o próximo comando. Isso ocorre porque o bloco de notas é um processo Win32 GUI e é executado em segundo plano. Por outro lado, se você iniciar um aplicativo de console como o & # 8220; ping. exe & # 8221 ;, o PowerShell aguardará até que esse processo seja concluído.
Mas e se eu quiser aguardar o processo Win32? Em cmd. exe, você deve fazer isso com o & # 8220; iniciar / aguardar / # 8221; mas este comando não está (diretamente) disponível no PowerShell. Então, o que fazemos?
O PowerShell executa executáveis ​​diretamente. Se aguarda que o processo seja encerrado, o código de saída será deixado em $ LASTEXITCODE. Agora, se um executável Win32 é o último comando em uma tubulação e não for redirecionado, o processo será executado em segundo plano. No entanto, se você canalizar sua saída para algo, o PowerShell aguardará o comando para sair.
Então, esta é uma espera simples (se não intuitiva) para aguardar um processo GUI para sair.
Alternativamente, se o processo já estiver sendo executado, você pode usar o Get-Process para obter as informações necessárias e, em seguida, fazer WaitForExit () nesse objeto.
Aqui está um exemplo um pouco mais sofisticado onde abrimos um documento em vez de iniciar um processo. Desta vez, encontraremos o processo por título da janela em vez do nome do executável.
Infelizmente, procurar um processo sempre significa que você pode encontrar o processo errado. Idealmente, você gostaria de obter o objeto Processo diretamente. Portanto, para um gerenciamento de processos mais preciso, você terá que usar a classe System. Diagnostics. Process e iniciar os processos por conta própria. Por exemplo, você pode usar [diagnostics. process] :: Start () para aguardar um processo:
Observe o uso de & # 8220; $ pwd \ foo. txt & # 8221; para especificar o caminho completo para o arquivo. Isso ocorre porque o PowerShell mantém sua própria idéia do diretório atual. (Esta nota se aplica ao uso de qualquer API que acessa o sistema de arquivos - você precisa dar um caminho absoluto.)
Agora, estamos começando a voltar ao nível de complexidade que você encontra em uma linguagem de programação. No entanto, você também tem todo o poder dessas linguagens. Aqui é um exemplo de script & # 8220; background. ps1 & # 8221; Isso permitirá que você execute um bloco de script separado em uma janela separada (ou na mesma janela, se você especificar o parâmetro - inconsole.
Este script permite que você faça coisas no PowerShell que você não pode fazer a partir do cmd. exe, mas pode fazer a partir do VBScript.
Finalmente, aqui estão mais duas maneiras de trabalhar com processos. Mesmo que o PowerShell não tenha um comando de início, o cmd. exe o faz para que você possa iniciar / aguardar.
E, por último, mas não menos importante, as extensões da comunidade PowerShell incluem um cmdlets Start-Process. Você pode obter uma lista desses recursos em:
Bruce Payette [MSFT]
Windows PowerShell Tech Lead.
Top Server & # 038; Ferramentas Blogs.
Postagens recentes.
DSC Resource Kit Release Fevereiro de 2018 7 de fevereiro de 2018 Atualização de Planejamento de Configuração de Estado Desejado (DSC) & # 8211; Janeiro de 2018 26 de janeiro de 2018 PowerShell Core 6.1 Roadmap 24 de janeiro de 2018 PowerShell Core 6.0: disponível em geral (GA) e com suporte! 10 de janeiro de 2018.
Eu tenho um script master powershell chamando um subscrito. O subscrito lança um erro, mas $ LASTEXITCODE no MASTER não parece atrapalhar.
Basicamente, meu processo pára no momento em que o comando throw é executado e o processo não é retornado para MASTER.
Existe uma maneira de contornar isso?
Muito obrigado por este artigo !
Seria realmente ótima ver uma versão atualizada deste com todas as extensões do V2 como Start-Process e as extensões de Jobs.
Obrigado por todo o trabalho duro, o PowerShell está se preparando para ser uma ferramenta realmente incrível para automação de processos!
Você pode encontrar mais detalhes aqui: [link] Shay [link]
Uma pequena pesquisa no google: & amp; lt; [link] & gt; onde a saída da ponta para o tubo é out-null. bloco de anotações.
Na verdade, estou integrando o VB e um programa escrito em C ++. Posso executar este programa C ++ clicando em um botão projetado no VB. Uma vez que eu clique no botão o prgram é executado na plataforma do DOS. Eu não quero essa plataforma DOS visível. Mas o processo C ++ deve continuar a ser executado em segundo plano, invisível.
Se eu passar o scriptblock que contém variável, o código não parece funcionar. Isso ocorre porque o processo filho não herda as variáveis ​​do pai. Como posso superar isso?
Bruce, eu andei jogando com os recursos para obter o processamento em segundo plano de blocos de script (em ps1.soapyfrog / 2007/01/22 / running-pipelines-in-the-background /)
É provável que este se torne mais amigável nos próximos lançamentos?
Eu percebo que os runspaces estão realmente disponíveis para aplicativos host, mas eles parecem úteis.
O seu comentário no "PowerShell Connect site & quot; é notado.
& # 8220; $ np = notepad get-process & # 8221; é * extemely * hit-miss se você usa o bloco de notas muito. Você poderia classificar os processos por data de início, criado por você, etc., em um esforço para mitigar erros, mas sim, # 8211; deveríamos ter fornecido uma maneira de obter o processo mais recente criado em um runspace. Ao invés de ter uma única variável $ LASTPROCESS, eu estava pensando que uma matriz de $ processar ao longo das linhas de $ erro seria bom. O processo criado mais recentemente seria mantido em $ process [0].
& gt; como PowerShell é um shell, shouldn & # 8217; t processo / controle de trabalho ser um cidadão de primeira classe.
Isso parece óbvio se não tivesse implementado um cmdlet New-Process / Start-Process, mas foi cortado do projeto em um ponto. Na triagem do que ocorreu na V1, nada além do gerenciamento básico de processos obteve uma classificação relativamente baixa, pois o PowerShell permite que você tenha acesso ao [Diagnostics. Process]. Isso significa que, embora possa ser complexo, você pode fazer praticamente qualquer coisa. Enviar para enviar é escolher como Jeffrey diz.
Envie um pedido no site de conexão do PowerShell para que outras pessoas possam mod-lo. Esta é uma importante fonte de dados no processo de tiragem para o que se passa na próxima versão. Se um número suficiente de pessoas o solicitar, então vai na lista curta para V. Seguinte.
E, respondendo a um comentário anterior:
& gt; Qual é o powershell equivalente aos processos de lançamento em máquinas remotas, ainda usa o WMI?
As operações remotas em 1.0 exigem que você use WMI, APIs removíveis ou outros mecanismos de controle remoto existentes. O PowerShell 1.0 não possui capacidades remotas explícitas. O suporte para remoting é um Pri 0 para a próxima versão.
$ np = bloco de notas get-process.
é um pouco errado & # 8211; qual processo do bloco de notas deve obter? Pior ainda, se houver uma partida, retorna um único objeto de Processo & # 8230; se não, uma matriz.
Talvez a próxima versão do PowerShell possa pré-carregar uma variável $ LASTPROCESS com o objeto de processo do último processo que iniciou, de modo que coisas como:
Além disso, como o PowerShell é um shell, o controle de processo / tarefa não deve ser um cidadão de primeira classe e ser suportado com cmdlets?
Sim & # 8211; Eu reparei a entrada no blog. Obrigado.
O $ LASTERRORCODE deve ser $ LASTEXITCODE?
O exemplo VB permite que você execute o processo em máquinas remotas. Caso contrário, um comando WSH muito mais simples pode executar processos. Qual é o powershell equivalente aos processos de lançamento em máquinas remotas, ainda usa o WMI?

Ei, Scripting Guy! Blog Hey, Scripting Guy! Blog.
Saiba mais sobre o Windows PowerShell.
Use o PowerShell para pausar um script enquanto outro processo sai.
Resumo: Saiba como usar o Windows PowerShell para pausar um script e esperar por outro processo para sair antes de continuar.
Ei, Scripting Guy! Estou tentando usar o Windows PowerShell para encerrar um aplicativo, mas o aplicativo é bastante complicado. Eu preciso parar um processo e aguarde que o processo seja concluído antes de iniciar o segundo processo. Tentei usar o cmdlet Start-Sleep para pausar a execução do script para permitir que os diferentes processos sejam concluídos, mas, infelizmente, diferentes sistemas são mais rápidos do que outros, então esta é uma proposição de sucesso ou falta. Você consegue descobrir uma maneira melhor de fazer isso?
Microsoft Scripting Guy Ed Wilson aqui. Bem, eu estou flutuando a uma distância de 35.000 pés (10.850 metros) ouvindo a Waltz of the Prophets de Stan Kenton, que na minha mente (como ex-saxofone da universidade) é um dos melhores padrões de jazz já escritos. Tenho jogado com o Windows PowerShell nas últimas horas (decidiu agrupar várias funções do meu utilitário em um módulo do Windows PowerShell, criar um manifesto e instalá-los na minha pasta do Windows PowerShell usando minha função de Modos de cópia). Você deve realmente investir na escrita dos módulos do Windows PowerShell em vez de escrever scripts únicos, se possível. O esforço pagará grandes dividendos.
De qualquer forma, estou sentado na Primeira Classe (fui atualizado) com uma mesa de trabalho decente, e meu novo laptop terá mais de oito horas e ainda fornecerá um desempenho decente, então a vida é boa. A solidão proporciona um tempo maravilhoso para explorar e jogar com o Windows PowerShell. Eu estou me forçando a ficar longe do WMI por enquanto, e ao invés disso estou me concentrando em diferentes maneiras de montar cmdlets, para ver se consigo criar algo legal. Fiquei bastante satisfeito com o truque do caminho que eu criei na Last. fm dois truques poderosos para encontrar posts do PowerShell Scripts.
Uma das coisas com as quais eu estava jogando é o cmdlet Wait-Process. É mais útil quando usado em um script, pois interrompe a execução de um script até que um processo termine. Isso permite uma maneira fácil de escrever um script que encerra múltiplos processos e mdash, um de cada vez.
Há duas maneiras pelas quais o cmdlet Wait-Process aceita entrada: um nome de processo ou um ID de processo. Por exemplo, posso iniciar uma instância do bloco de notas e, em seguida, usar o processo de espera para pausar até que o bloco de notas seja fechado.
Quando qualquer instância do processo do Bloco de Notas sai, o controle para o script (ou console do Windows PowerShell) retorna. Isso funciona quando você não se importa qual a cópia do bloco de notas fecha, ou quando você sabe que há apenas uma instância de um processo em execução.
Uma maneira mais útil de fazer isso é capturar o ID do processo quando ele é iniciado e usar esse ID de processo específico com o cmdlet Wait-Process. Essa técnica usa o cmdlet Invoke-WmiMethod e é mostrada aqui:
$ proc = Invoke-WmiMethod - Class win32_process - Name create - ArgumentList "notepad"
Wait-Process - Id $ proc. ProcessId.
Um dos meus truques favoritos (mas não está nos meus dez melhores truques favoritos do Windows PowerShell) canaliza o Notepad to Out-Null para interromper o processamento do script até o Bloco de Notas se fechar. Em seguida, removo a cópia do arquivo de texto que foi visualizado. Esta é uma ótima maneira de lidar com arquivos temporários. Essa técnica é mostrada no código a seguir:
notepad $ tmpfile | fora-nulo.
O problema com este & ldquo; trick & rdquo; é que isso não funciona para outras coisas. Por exemplo, se eu escrever informações de processo em formato HTML e exibir que no Internet Explorer, o truque Out-Null não interrompe o script. Além disso, se eu tentar fechar o Internet Explorer sem um ID de processo específico, talvez eu possamos fechar mais de uma instância do Internet Explorer. O código que se segue cria um arquivo temporário em um local temporário. Ele muda a extensão de arquivo para HTML e, em seguida, usa o cmdlet Convertto-HTML para enviar dados formatados HTML do cmdlet Get-Process. Eu uso o cmdlet Out-File para escrever meus dados formatados em HTML para um arquivo e então eu uso o cmdlet Invoke-Item para abrir o arquivo HTML no Internet Explorer (pelo menos no meu sistema, esta metodologia irá abrir o arquivo HTML com o programa padrão associado a essa extensão):
Out-File - FilePath $ tmpFile - Incoding ascii - append.
Nota Veja o excelente convidado Hey, Scripting Guy! Postagem do blog, funções de proxy: especifique seus PowerDocs Core PowerShell, escritos pelo Microsoft PowerShell MVP Shay Levy para obter uma maneira de adicionar um parâmetro filepath ao cmdlet ConvertTo-HTML. Ao criar uma função de proxy, você pode evitar uma chamada para Out-File.
O truque Out-Null não pausará o script e permitirá a limpeza, e não saberemos qual versão ou instância do Internet Explorer pode ser morta de qualquer maneira, então é necessário que haja uma nova maneira. Aqui estão os passos envolvidos:
Crie um nome de arquivo temporário. Altere a extensão do arquivo para html. Pipe dados para o cmdlet ConvertTo-Html. Pipe os dados de ConvertTo-Html para Out-File e crie um documento HTML. Use o método Invoke-WMIM para abrir o arquivo e armazenar os valores de retorno. Use o cmdlet Wait-Process para interromper a execução do script e aguarde o fechamento do processo. Use Remover-Item para remover o arquivo temporário.
O script GetProcessInfoDisplayHTMLtrackProcessAndRemoveTmpFile. ps1 ilustra estas etapas.
-ChildPath "internet explorer \ iexplore. exe"
Out-File - FilePath $ tmpFile - Incoding ascii - append.
$ iepid = Invoke-WmiMethod - Class win32_process - Name create - Argument "$ iepath $ tmpfile"
Wait-Process - Id $ iepid. ProcessId.
No script, a primeira coisa que faço é obter um nome de arquivo temporário. O método GetTempFileName cria um nome de arquivo temporário na localização temporária. Um exemplo desse nome de arquivo é mostrado aqui:
Eu dividi a corda no período. Este não é um método confiável para dividir nomes de arquivos e remover a extensão do arquivo, mas funciona aqui. Por exemplo, isso irá falhar se um nome de arquivo tiver dois períodos no nome. Na minha ocasião, concatenei o nome do arquivo temporário com & ldquo;.html & rdquo; e acabou com um nome de arquivo com dois períodos, o que é, naturalmente, um nome de arquivo perfeitamente aceitável. Aqui estou simplesmente explorando outras formas de criar um nome de arquivo temporário com uma extensão de arquivo HTML. O Internet Explorer requer um arquivo para ter uma extensão de arquivo HTML, ou não irá renderizar a página corretamente. Por exemplo, se eu ficar com a extensão de arquivo. tmp, a página é exibida como mostrado na figura a seguir.
Eu gosto de usar o cmdlet Join-Path para criar caminhos. Para fazer isso, preciso fornecer a parte do caminho (caminho pai) e a parte caminho da criança (caminho filho) do caminho. Não estou restrito a simplesmente caminho \ executável na minha formatação. Eu posso, por exemplo, incluir diretórios adicionais em minha parte de caminho filho do comando. Neste exemplo, eu uso uma variável ambiental para recuperar o caminho para os arquivos do programa x86 e, em seguida, adiciono o restante do caminho para o executável do Internet Explorer. Eu quebrei o comando e usei o caractere do backtick (`) para a continuação da linha. Eu normalmente não faria isso, mas é necessário encaixá-lo na página. Esta parte do script segue:
-ChadPath "internet explorer \ iexplore. exe"
Nota Ao copiar o código do Hey, Scripting Guy! Blog, é possível que os caracteres estranhos apareçam após o caractere do backtick, e esse personagem invisível quebrará o código. A correção é colar o código no Windows PowerShell ISE e usar o caractere de retrocesso para apagar os caracteres invisíveis que seguem o caractere do backtick.
Agora crio uma página HTML usando o cmdlet Convertto-HTML. Eu escrevo o código HTML em um arquivo usando o cmdlet Out-File. Este código é mostrado aqui:
Out-File - FilePath $ tmpFile - Incoding ascii - append.
Eu uso o cmdlet Invoke-WMIMethod para chamar o método create da classe Win32_Process WMI. Eu uso essa metodologia porque retorna o ID do processo da instância recém-criada do Internet Explorer. Eu armazeno o ID do processo em uma variável chamada $ iepid. Este código é mostrado aqui:
$ iepid = Invoke-WmiMethod - Class win32_process - Name create - Argumento "$ iepath $ tmpfile"
Agora paro a execução do script até a nova instância do Internet Explorer desaparecer. Depois que ele desaparece, eu chamo o cmdlet Remove-Item, e eu exclui o arquivo HTML temporário, como mostrado aqui:
Wait-Process - Id $ iepid. ProcessId.
O arquivo HTML que o script cria e exibe é mostrado na figura a seguir.
SK, é tudo o que há para usar o cmdlet Wait-Process para pausar a execução do script e aguardar a conclusão de um processo. Convido você para se juntar a mim amanhã para obter mais coisas legais do Windows PowerShell.
Convido você a me seguir no Twitter e no Facebook. Se você tiver alguma dúvida, envie-me um e-mail para o scriptermicrosoft ou publique suas perguntas no Official Scripting Guys Forum. Te vejo amanhã. Até então, paz.
Ed Wilson, Microsoft Scripting Guy.
Cancelar resposta.
Viajando Primeira Classe (ele foi atualizado) parece que a importância do blog HSG aumentou novamente!
Sua indicação "estou me forçando a ficar longe da WMI por enquanto" me faz rir, se eu olhar para este artigo de blog, notando que o método Invoke-WMI apareceu assim que eu puder contar com três :-)))
Bem, de volta à segurança, concordo que podemos controlar uma grande parte da funcionalidade operacional com powershell se pudermos ficar com PS durante todo o processo, o que não é o caso do problema da SK. Está ficando complicado se ele começou sua aplicação fora do powershell e espera que algumas partes dele desligem. Nós provavelmente não criamos o processo de aplicação da raiz em PS e não temos o PID a mão (alguém deve llok-lo, se não possamos usar o nome do processo). Se o aplicativo criar seus próprios processos durante a execução, talvez não seja fácil seguir a seqüência do novo processo gerado e encerrado, então, provavelmente, só esperamos o fim do aplicativo completo se não iniciarmos cada um parte dele separadamente.
De qualquer forma, seus exemplos mostram o que podemos fazer no powershell para controlar o fluxo de trabalho dos processos que criamos com o PS. Isso é bom o suficiente, enquanto não tenhamos que controlar múltiplas aplicações em paralelo ou ter que realizar mais cálculos enquanto isso. Isso é quando temos que considerar trabalhos em segundo plano e eventos assíncronos que podem nos ajudar a ficar atentos com o fluxo de trabalho em andamento.
Lembro-me de alguns artigos anteriores do blog aqui que apontaram nessa direção.
Mas esse tópico ganhou não seja o querido de todos & # 8230; com certeza! & # 8230; O material de Ninja do powershell daquele 🙂
Klaus Schulte, o atendente de voo disse: "É o Scripting Guy" e me mudou para o primeiro (não realmente, mas parece bom). Além disso, você me pegou, eu não consegui passar por um artigo inteiro sem falar sobre WMI 🙂 Sim, este exemplo, é um caso de vantagem para ter certeza. But the cool thing is there is the Wait-Process cmdlet, and it can be used easily to solve some real world types of problems. It is also one of those cmdlets that "no one talks about" and I wanted to help correct that. Thank you for your comments Klaus. I look for them every morning 🙂
If you are depending on a process spawned elsewhere, WMI works. But if it's a process spawned by your own script, why won't Start-Process work? It gives you the handle and you can - wait if you need it to complete before starting other work.
What's more, you can get the CPU usage of the spawned process and at least watchdog it and restart it if it stalls. I've used that to control a media encoder that needed to run 24/7 and liked to hang from time to time.
Why not Start-Process; By default the Start-Process cmdlet does not return anything. In order to get anything from the Start-Process cmdlet, it is necessary to use the Start-Process - Passthru option. When - passthru is used, it will return a diagnostics. process object, which does indeed include the Process ID. I was just sort of making a joke about not using WMI, and I wanted to reinforce using the Invoke-WMIMethod. As always, there are many many different ways of doing things in powershell. Thank you for your comment, and for helping to mention a different way of doing things.
A quick question.
Im having a problem with Enter-PSSession that the connection takes a while before it comes trough and the script "continues" so that it does not pick up the next few command lines. I have tried with start-sleep and wait-event, but no luck.
I use this to login to the server.
$secstr = New-Object - TypeName System. Security. SecureString.
$cred = new-object - typename System. Management. Automation. PSCredential - argumentlist $username, $secstr.
$no91gpotestsrv = New-PSSession - Name no91-gpotestsrv - ComputerName no91-gpotestsrv - Credential $cred.
(here it does not stop for the Enter-PSSession to stop but just continues, what can i do here?)
#Mapping av network drive hvor filer ligger.
$net = new-object - ComObject WScriptwork.
#Kopiering av filer og rename.
$return_fileversion1 = (Get-Command "c:infrontbinstreamingserver_x64.exe").FileVersionInfo. Fileversion.
$return_fileversion2 = (Get-Command "r:ServersStreamingServerLatestx64streamingserver_x64.exe").FileVersionInfo. Fileversion.
IF($return_fileversion2 - gt $return_fileversion1)
$currentdate = get-date - Format yyyyMMdd.
rename-item c:tempbinserver_x64.exe - newname ("server_x64.exe." + $currentdate)
Copy-item r:ServersbuildServerLatestx64server_x64.exe c:tempbin.
$text = "New file copied in with Fileversion + $return_fileversion2"
ELSEif($return_fileversion2 - eq $return_fileversion1)
Write-host "Destination file is equal as source file"
ELSEif($return_fileversion1 - gt $return_fileversion2)
Write-host "Destination file is greater then source file"