Chris's questions

Normalmente, eu recorro normalmente:

recipe-X:
  $(MAKE) recipe-Y

No entanto, no MacOS eu uso o recurso de forma diferente:

recipe-X:
ifeq ($(shell uname -s),Darwin)
  colima ssh -- make $@
else
  <recipe script>
endif

Devo usar $(MAKE), ou esse é um caso em que eu realmente deveria make? Não estou claro sobre as diferenças entre os dois modos neste contexto, e como eles irão interagir. Meu entendimento é que $(MAKE)é uma macro que propaga paralelismo, ambiente e outras preocupações para o sub-make... mas estou tendo alguns problemas.

O que notei é que $(MAKE)pode quebrar comandos que, de outra forma, acessariam a rede dentro do vmpropagando as variáveis ​​de ambiente. Mas não tive sucesso com os comandos baseados em rede usando comandos make.. comuns que funcionam quando eu sshentro no vme invoco via cli.

Então, antes de me aprofundar e fazer algo muito inteligente, imaginei que poderia haver uma maneira especial de makeusá-lo para esse propósito.

Considere um makefileitem multilinha:

define ITEM
line $$ONE
line $$TWO
endef

item:
  echo '$(ITEM)' | ... > $@

O problema é que, à medida que o ITEM fica complexo, corro o risco de obter erros de cotação e outros problemas ao repetir o item.

Eu também poderia executar com uma exportação:

export ITEM
item:
  print "%s\n" '$${ITEM}' | ...

Mas não tenho certeza se haverá os mesmos bugs.

Existe alguma função make que injetará o conteúdo de uma variável diretamente no shell, como se fosse enviado para /dev/stdin?

# e.g. something like:
$(info $ITEM) | ...

Entendo que posso escrever o valor diretamente em um arquivo, que poderei processar via shell. Mas ser capaz de escrevê-lo diretamente em um pipeline causaria um curto-circuito nisso.

• isso terá uma série de comandos ou introduzirá requisitos comosponge
• isso também pode fazer com que eu tenha que mudar de coisas simples envsubstpara coisas mais pesadas, como sedpermitir modificações no local (para evitar a instalação de esponjas)

Também entendo que posso exportar o valor para todos os subshells:

• isso pode ser problemático se minha extensão estiver incluída em um projeto make recursivo ou em um projeto make com uma grande quantidade de sobrecarga de exportação (por exemplo, parameter?=varsaquele padrão para valores env introduz uma grande quantidade de sobrecarga quando .SECONDEXPANSIONestá habilitado)
• em particular, exportar muito pode prejudicar o desempenho da zshconclusão de tabulação para make, que é um requisito básico para usuários de Mac

Mas não tenho provas de exportação e echo "$$ITEM"ou print("%s/\n") "$$ITEM"terei escapes adequados. Então terei que testar.

O que não é "uma maneira", mas a melhor prática pretendida para fazer isso?

Se a resposta for: use $(file ..)e modifique o arquivo no local a partir daí, então que assim seja; só quero ter certeza de que é o ideal.

Suponha que eu precise executar alguma tarefa antes que um tipo de arquivo específico esteja pronto para ser criado, mas gostaria de executar a regra genérica:

foo.bar:
   # do something to prepare to make foo.bar

%.bar:
   # generate the `.bar` filetype

Como avalio a receita curinga para gerar foo.bar, tendo definido foo.barpara algum trabalho de preparação específico?

No BASH, posso armazenar JSON em uma variável de ambiente via jq:

export FOO=$(curl ... | jq -Rs)

Agora, se eu carregar isso em python:

bar=os.environ["FOO"]

barterá algo como: {\\"this\\":\\"that\\"}, o que é um problema ao carregar com json:

json.loads(bar) # error

Eu tentei algumas coisas repr, incluindo rf'{os.environ["FOO"]}'e assim por diante, mas não parece haver uma maneira gerenciada internamente de eliminar as barras extras.

Como faço para eliminar as barras extras por meio de funções de string? Prefiro não substituí-los simplesmente por uma única barra, pois talvez seja necessário alterar esse código novamente em algum momento no futuro.

Suponha que eu tenha uma string:

"password"

E pode estar na forma de uma string segura criptografada convertida em texto. Este texto de string seguro pode ser descriptografado ConvertFrom-SecureStringpara recuperar a "senha":

"1213132131....1232131" | ConvertFrom-SecureString |%{echo $_}
password

Existe alguma maneira de o PowerShell me dizer se a string de entrada já está descriptografada?

Ou preciso encontrar outra maneira de saber se a string de entrada está em texto simples ou criptografada como uma string segura?

Suponha que eu tenha um script bash complexo:

x.sh
#! /bin/bash
. include/this/script.sh
. include/this/other/script.sh 
...
foo="foo$bar"
echo $foo

Existe alguma configuração ou maneira de fazer com que o BASH ecoe todo o código-fonte que ele origina, incluindo o script principal quando eu o invoco, para que eu saiba exatamente o que está acontecendo?

Motivação: Estou tentando testar alguns comandos relacionados ao processo com um simples trabalho de powershell. No entanto, todos os trabalhos do powershell são denominados "powershell" na tabela de processos. Portanto, preciso do identificador de processo que posso usar para filtrar Get-Processa saída.

Portanto, a pergunta 'maior' pode ser mais fácil de responder, mas, do jeito que está, acho que tenho uma solução se eu pudesse conectar um trabalho do powershell ao seu ID de processo ("Handle").

Como obtenho o ID do processo de um trabalho do powershell? (este não é o JobID).

$job = Start-Job -Name $jobName -ScriptBlock { while($true){sleep -Seconds 1}}
$processes = Get-Process

$jobHandle = ???
$jobProcess = $processes |? {$_.Handle -eq $jobHandle}

Como obtenho as informações ausentes simbolizadas por '???' ?

Lidando com o problema XY e reformulado de forma mais geral, se isso for impossível porque tudo é adquirido na sessão atual do powershell, a grande questão é: como crio um processo arbitrariamente nomeado ou manipulado que eu possa fazer qualquer coisa, do powershell, para testando?

# how do I start this code block as an arbitrary named process?
name="test-Get-Foo.1.2"
{
  while($true){
    sleep -Seconds 2
  }
}

# ???

$proc=Get-Process |? {$_.Name -like "test-Get-Foo*"}