intelfx's questions

Estou tentando usar o GNU parallel para executar um comando para todas as combinações de vários sinalizadores de alteração de comportamento:

parallel 'cmd --foo {1} --bar {2} {3} out.foo={1}.bar={2}/{3/}' ::: 0 1 ::: 0 1 ::: in/*

Isso deve gerar uma série de invocações como:

cmd --foo 0 --bar 1 'in/fileXYZ' 'out.foo=0.bar=1/fileXYZ'
cmd --foo 1 --bar 0 'in/fileXYZ' 'out.foo=1.bar=0/fileXYZ'

No entanto, a CLI dessa ferramenta é irregular: --fooaceita um argumento booleano, enquanto --barnão aceita um argumento (e também não tem forma negativa). Assim, as invocações devem se parecer com isso:

cmd --foo 0 --bar 'in/fileXYZ' 'out.foo=0.bar=1/fileXYZ'
cmd --foo 1       'in/fileXYZ' 'out.foo=1.bar=0/fileXYZ'

Qual é a melhor maneira (menos prolixa) no GNU parallel de transformar um argumento de 1ou 0na presença ou ausência de --barna linha de comando?

Imagine que eu queira mover (renomear) uma árvore de diretórios /var/lib/postgres/datapara /var/lib/postgres/data.old:

/var/lib/postgres
└── data
    ├── base
    │   ├── 16390
    │   │   └── <...>
    │   └── <...>
    │       └── <...>
    ├── global
    │   └── <...>
    ├── pg_wal
    │   ├── <...>
    │   ├── archive_status
    │   └── summaries
    ├── <...>
    └── postmaster.pid

Normalmente, basta uma única rename()chamada de sistema e um único comando: mv data data.old.

Entretanto, imagine que haja um ponto de montagem ativo em algum lugar nessa árvore de diretórios, por exemplo, pg_walem um sistema de arquivos diferente:

$ findmnt
<...>
├─/var/lib/postgres                           stank/data/stratofortress/PostgreSQL                              zfs       rw,noatime,xattr,posixacl,casesensitive
│ └─/var/lib/postgres/data/pg_wal             stank/data/stratofortress/PostgreSQL/pg_wal                       zfs       rw,noatime,xattr,posixacl,case-sensitive
<...>

Alternativamente, imagine que o nome de destino ( data.old) já existe e alguns ramos da árvore de diretórios já foram criados (porque são pontos de montagem, na mesma linha acima).

~~Em ambos os casos~~ No último caso, mvse recusará a fazer qualquer coisa. Executar uma cópia profunda com algo como a cp -aé proibitivamente caro, e reflinks não estão disponíveis por razões que estão fora do escopo desta questão.

Existe uma ferramenta que pode executar um "movimento recursivo" ideal, descendo iterativamente em partes da hierarquia de origem para cada subárvore que não pode ser renomeada por completo, até arquivos individuais (finalmente voltando a fazer uma cópia de cada arquivo individual, se necessário)?

NB: Estou procurando uma solução generalizada que possa ser estendida a qualquer número de subárvores e conflitos, ou seja, mv data/* -t data.old; mv data/pg_wal/* -t data.old/pg_walnão é uma solução. Em outras palavras, por favor, não infira nenhuma restrição ou caso especial do exemplo acima.

Estou escrevendo um script wrapper de shell que deve funcionar como um pager (recebendo entrada em stdin e executando saída em um tty).

Este wrapper prepara o ambiente e as linhas de comando e, em seguida, inicia dois processos em um pipeline: o primeiro é um filtro não interativo e o último é o pager real que precisa controlar um tty (ou melhor, gera o próprio pager real) :

#!/bin/bash

...

col -bx | bat "${bat_args[@]}" --paging=always

A árvore de processos resultante é assim:

<parent>
\- wrapper.sh
   |- col -bx (dies)
   \- bat ...
      \- less ...

O col -bxprocesso sai após filtrar a entrada e é colhido pelo shell.

É possível se livrar do processo shell, de modo que ele não permaneça enquanto o pager estiver em execução?

Pensei em uma solução alternativa usando substituição de processo:

exec bat "${bat_args[@]}" --paging=always < <(col -bx)

Porém, o col -bxprocesso não é colhido pelo shell e permanece no estado Z. Existe uma maneira "certa" de escrever esse wrapper?

Uma construção semelhante a IFS= read -r varé frequentemente vista como uma forma "canônica" no Bash de ler uma linha de entrada em uma variável (por exemplo, em unix.SE ).

É bastante claro por que definir um vazio $IFSpode ser benéfico em geral, ou seja, para controlar (evitar) a divisão de palavras. No entanto, estou tendo problemas para entender por que isso é especificamente necessário ao ler uma única variável. O manual do bash diz:

Se houver mais palavras do que nomes, as palavras restantes e seus delimitadores intermediários serão atribuídos ao sobrenome

Então, mesmo sem alterar o IFS, se readfor passada uma única variável, não deveria acabar salvando a linha inteira naquela variável, conforme desejado? Qual é o motivo para definir um vazio $IFSneste caso?

Estou tentando usar o GNU Parallel para executar um comando para cada argumento de entrada, usando esse argumento como o diretório de trabalho do comando (sem anexá-lo à linha de comando).

Basicamente, o que preciso fazer é:

/foo -> "cd /foo; mycmd"
/bar -> "cd /bar; mycmd"
/baz -> "cd /baz; mycmd"

Parallel tem --workdiro que parece fazer o que eu quero em virtude do suporte {}a strings de substituição:

--workdir meudir
--wd meudir

Os trabalhos serão executados no diretório mydir. O padrão é o diretório atual da máquina local e o diretório de login para computadores remotos.
<...>
mydir pode conter strings de substituição do GNU paralelo.

Para evitar que o argumento seja anexado à linha de comando, tentei usar -n0or -N0:

--max-args max-args
-n max-args

Use no máximo argumentos max-args por linha de comando.
<...>
-n 0 significa ler um argumento, mas inserir 0 argumentos na linha de comando.

No entanto, isso não parece funcionar:

$ mkdir -p $HOME/{foo,bar,baz}
$ printf '%s\n' $HOME/{foo,bar,baz} | parallel --workdir '{}' -n0 'pwd'
parallel: Error: Cannot change into non-executable dir : No such file or directory

Observe o espaço antes do :, que não é um erro de digitação no paralelo GNU, mas uma indicação de que o workdir foi avaliado como uma string vazia. Isso se torna evidente se eu acrescentar uma string fixa a {}, caso em que todos os pwds imprimem essa string fixa:

$ printf '%s\n' $HOME/{foo,bar,baz} | parallel --workdir '/{}' -N0 'pwd'       
/
/
/

O que estou fazendo de errado?