Perguntas[pipe](unix)

Mostrar linhas passadas por here-document no stdout:

cat <<EOF
foo
bar
baz
EOF
foo
bar
baz

Quero corresponder uma string com grep via pipe:

cat <<EOF
foo
bar
baz
EOF 
|grep 'ba'

Por que não é possível passar o stdout pelo pipe para o comando grep?

Acabei de ver um exemplo de uso echopara colocar várias coisas no pipeline (para jq).

echo '{"A": {"a": 1}}' '{"A": {"b": 2}}' '{"B": 3}' |\
  jq --slurp 'reduce .[] as $item ({}; . * $item)'

Se bem entendi, isso parece colocar três objetos no pipeline de um lado e, do outro, jqrecebê-los e colocá-los em um array e reduzi-lo com um operador de mesclagem.

Isso é surpreendente para mim e não tenho certeza de como funciona ter várias coisas no arquivo stdin.

Mais especificamente, como o sistema sabe que a entrada é de três arquivos e onde cada arquivo começa/termina?

Se eu apenas fizer a parte echo echo '{"A":1}' '{"A": {"b": 2}}' '{"B": 3}', a saída não parece ter nenhum delimitador visível entre os três objetos:

{"A":1} {"A": {"b": 2}} {"B": 3}

As aspas simples têm alguns efeitos especiais que informam ao próximo filtro ( jq) os limites? Ou como jq conhece os limites?

(Isso é com Ubuntu 24.04, jq 1.7.1)

De acordo com pipe(7):

Se todos os descritores de arquivo referentes à extremidade de leitura de um pipe tiverem sido fechados, então a write(2)fará com que um SIGPIPEsinal seja gerado para o processo de chamada. Se o processo de chamada estiver ignorando esse sinal, write(2)falhará com o erro EPIPE.

Por que o Unix precisa ter o SIGPIPEsinal quando write()pode simplesmente retornar EPIPEdiretamente? Meu entendimento é que os sinais são destinados a coisas que são inerentemente assíncronas (por exemplo, encerramento de um filho, interrupção terminal). Mas SIGPIPEsó é gerado como o resultado imediato de uma chamada to write(); nesse caso, ele sempre pode simplesmente retornar EPIPEto to caller para indicar o erro ao chamador.

Por que foi considerado necessário ter SIGPIPEalém de EPIPE?

Qual é uma boa maneira de executar um hash SHA256d (SHA256 duplo) no terminal padrão de uma nova instalação do OpenBSD isolada em rede?

Aqui está o que estou fazendo:

echo test > testfile
cat testfile | openssl dgst -binary | openssl dgst

Isso me dá um número que termina em0xe0b6

Gostaria de saber se existe uma maneira mais concisa/melhor?

Configurei o rsyslog para encaminhar determinadas mensagens de log para um pipe nomeado /tmp/logger.pipe. Em seguida, tenho um processo separado lendo o pipe nomeado. Seção relevante de/etc/rsyslog.conf

# Remote Logging (silly conditional rule needed for specific logging scenario)
$template RFC5424Format,"<%PRI%>1 %timegenerated:1:10:date-rfc3339%T%timegenerated:12:19:date-rfc3339%.%timegenerated:21:26:date-rfc3339%Z %HOSTNAME% - - -%msg%\n"
if ($msg contains 'remote="true"') then /tmp/logger.pipe;RFC5424Format

Permissões em /tmp/logger.pipe

prwxrwxrwx 1 ftp root 

Estou implantando este aplicativo em duas máquinas diferentes. Uma máquina possui rsyslog v3.xx e a outra v5.xx

O aplicativo está funcionando perfeitamente na máquina com o rsyslog v5.xx. No entanto, estou tendo um comportamento estranho na máquina com o rsyslog v3.xx Especificamente:

1. O rsyslogd às vezes leva uma eternidade para iniciar na inicialização (era muito rápido antes de eu adicionar a nova regra).
2. Quando a leitura do processo logger.pipeé reiniciada, o rsyslogd parece parar de gravar dados no pipe nomeado após a retomada do processo de escuta. A única maneira de corrigir isso é reiniciar manualmente o rsyslogd

Existe algum truque com a configuração do rsyslog que estou perdendo ao trabalhar com pipes nomeados? Algum outro problema de permissão que eu possa estar ignorando? Estou confiante no aplicativo, pois ele tem funcionado de forma muito robusta com a versão v5.xx do rsyslog. Infelizmente não tenho como atualizar a versão v3.xx na máquina com a qual estou tendo problemas.

Alguma ideia?

Atualização: posso ter diagnosticado o problema - parece ser um problema em que o rsyslogd fecha a conexão de gravação com o canal se não houver leitores. No entanto, o aplicativo leitor usa fopen() que bloqueia até que haja um gravador correspondente.

Por alguma razão, isso não é um problema no rsyslog v5.xx:

1. estado inicial onde rsyslogd e logger.out têm o pipe aberto com sucesso

2. problema de reinicialização em _logger.out, rsyslogd ainda tem gravação aberta no pipe

3. _logger.out é retomado e tudo funciona corretamente novamente

Mas esse comportamento é diferente no rsyslog v3.xx:

1. estado inicial onde rsyslogd e logger.out têm o pipe aberto com sucesso

2. problema de reinicialização em _logger.out, rsyslogd por algum motivo fecha a conexão com o pipe

Referindo-me a isto https://stackoverflow.com/a/31356602 , escrevi este código:

#!/bin/bash

# Define the two strings to compare
string1="First string with some random text."
string2="Second string with some random text and some changes."

# Create a temporary directory
temp_dir=$(mktemp -d)

# Create temporary files for the strings
file1="$temp_dir/string1.txt"
file2="$temp_dir/string2.txt"
echo -e "$string1" > "$file1"
echo -e "$string2" > "$file2"

# Use the git diff command to compare the temporary files
git diff --no-index --word-diff=color --word-diff-regex=. "$file1" "$file2"

# Delete the temporary directory
rm -rf "$temp_dir"

que retorna:

Agora estou tentando condensá-lo em uma única linha:

#!/bin/bash

# Define the two strings to compare
string1="First string with some random text."
string2="Second string with some random text and some changes."

# Use the git diff command to compare the strings
git diff --no-index --word-diff=color --word-diff-regex=. <('%s\n' "$string1") <(printf '%s\n' "$string2")

mas eu entendo:

Como posso passar strings como arquivos git diffsem criar explicitamente arquivos temporários?

Observação. Meu objetivo é comparar "visualmente" (em nível de caractere) duas strings (curtas), obtendo uma saída semelhante a esta:

em que as diferenças entre as duas strings comparadas são destacadas em uma única string. O resultado git diffé ideal, mas também estou aberto a outras soluções.

Estou executando um script (em um projeto Laravel) que leva algumas horas para ser concluído. nohuppara evitar que ele saia se minha sessão ssh estiver desconectada.

nohup php artisan do:thing 2>&1 | tee ~/tmp

Começa bem, mas depois de algum tempo, recebo um erro de pipe quebrado e ele para de produzir coisas e teetambém - o documento para nesse ponto.

Acho que é porque o teeprocesso foi interrompido pela queda da sessão ssh? Posso evitar isso?

Eu poderia rejeitar o processo tee e evitar que o ssh o termine?

Estou tentando capturar/canalizar a saída do seguinte:

arecord -f S16_LE -qd 5 arquivo && arquivo sox -n stat

saída:

Amostras lidas: 8000 Comprimento (segundos): 1,000000 Escalado por: 2147483647,0 Amplitude máxima: 0,992188 Amplitude mínima: -0,992188 Amplitude da linha média: 0,000000 Norma média: 0,093221 Amplitude média: -0,015338 Amplitude RMS: 0,232947 Delta máximo: 0. 617188 Delta mínimo: 0,000000 Delta médio : 0,001067 Delta RMS: 0,009643 Frequência aproximada: 52 Ajuste de volume: 1,008

Preciso capturar os dados para converter para json. O problema é que "SOX" parece desafiar qualquer método que eu normalmente usaria para capturar/canalizar o stdout. Alguma recomendação?

Eu sinto que isso deveria ser simples. Eu tenho um diretório com mais de 1000 arquivos gzip-ed. Eu gostaria de armazená-los todos e concatená-los.

A execução gzip -dk *.gz | cat > output.fileproduz o seguinte erro:Too many levels of symbolic links

Ideias?

Estou tentando concatenar vários arquivos/fluxos de entrada em um fluxo (usando o comando imaginário stream-cat), canalizar esse fluxo para dentro sshe no host remoto, separá-lo de volta em arquivos/fluxos individuais ( stream-sep), como neste exemplo, que é para demonstração propósitos apenas:

stream-cat <( zfs send tank/vm@snapshot ) somefile.txt | ssh user@host "stream-sep >( zfs receive tank/vm@snapshot ) somefile.txt"

Explicação do exemplo: zfs sendgera um grande fluxo de dados cujo tamanho não é conhecido antecipadamente (é por isso que tarnão pode lidar com isso). Esse fluxo de dados é concatenado com o conteúdo de um arquivo regular somefile.txt. O fluxo resultante é canalizado para ssh, onde é separado novamente. O primeiro fluxo é canalizado para zfs receive, enquanto o segundo é gravado em um arquivo regular.

Tal programa deve ser simples de implementar lendo fluxos não pesquisáveis ​​em blocos e sempre escrevendo o tamanho do bloco seguido pelos dados, até que o final do fluxo seja alcançado. A sobrecarga seria mínima.

Esse programa já existe?