roaima's questions

Considere que tenho um conjunto de sete arquivos:

item1_data
item2_data_more
item3_data
item4_data
item5_data_more
other6_data
other7_data_more

e quero combinar os três que começam com itemmas não terminam com more. Dado que este é um cenário de exemplo, você deve aceitar que não é suficiente corresponder ao padrão de correspondência positivo item*data?(ou qualquer variante trivial).

Estou usando bashcom extglobhabilitado. Para casos simples, a descrição na página de manual é suficiente (" !(pattern‐list)Corresponde a qualquer coisa, exceto a um dos padrões fornecidos "). No entanto, aqui preciso conseguir uma correspondência itemnegativa para data. Finalmente encontrei um que funciona, mas o que não entendo é por que funciona, mas outros falham.

shopt -s extglob                                                # Enable extended globbing
touch {item{1,3,4},other6}_data {item{2,5},other7}_data_more    # Example data set

ls !(*more)                                                     # Non-"item" files too
item1_data  item3_data  item4_data  other6_data

ls item*!(more)                                                 # All "item" files
item1_data  item2_data_more  item3_data  item4_data  item5_data_more

ls item!(*more)                                                 # Works as required
item1_data  item3_data  item4_data

Por que o segundo falha e o terceiro é bem-sucedido? Estou pensando que o curinga deveria ser válido em qualquer posição - mas claramente não é. Alguém pode me iluminar, por favor.

Quando crio uma mdadmmatriz RAID 1, o comando é concluído com êxito, mas recebo um aviso.

Características do sistema ("alvo" Debian/Raspbian em um Pi 3):

uname -a
Linux pi 4.9.35-v7+ #1014 SMP Fri Jun 30 14:47:43 BST 2017 armv7l GNU/Linux

mdadm --version
mdadm - v4.1 - 2018-10-01

head -n4 /etc/os-release
PRETTY_NAME="Raspbian GNU/Linux 11 (bullseye)"
NAME="Raspbian GNU/Linux"
VERSION_ID="11"
VERSION="11 (bullseye)"

Exemplo trabalhado:

dd if=/dev/zero bs=1M count=128 >/tmp/r1.img               # 128MB will do nicely
cp /tmp/r1.img /tmp/r2.img                                 # Another slice
for r in 1 2; do losetup /dev/loop$r /tmp/r$r.img; done    # Associate block devices

mdadm --create /dev/md0 --level=raid1 --raid-devices=2 --metadata=default /dev/loop1 /dev/loop2

Mensagem de aviso:

mdadm: Fail create md0 when using /sys/module/md_mod/parameters/new_array
mdadm: array /dev/md0 started.

O status de saída ( $?) é zero, ou seja, conclusão bem-sucedida.

Verificação de status ( cat /proc/mdstat) após alguns instantes, após permitir a sincronização da nova matriz RAID:

Personalities : [raid1]
md0 : active raid1 loop2[1] loop1[0]
      130048 blocks super 1.2 [2/2] [UU]

unused devices: <none>

O "arquivo" referenciado existe:

ls -l /sys/module/md_mod/parameters/new_array
--w------- 1 root root 4096 Sep 13 10:34 /sys/module/md_mod/parameters/new_array

Aqui está o que parece ser o segmento relevante da corrida strace mdadm …:

openat(AT_FDCWD, "/run/mdadm/creating-md0", O_RDWR|O_CREAT|O_LARGEFILE, 0600) = 4
close(4)                                = 0
openat(AT_FDCWD, "/sys/module/md_mod/parameters/new_array", O_WRONLY|O_LARGEFILE) = 4
write(4, "md0", 3)                      = -1 EINVAL (Invalid argument)
close(4)                                = 0
write(2, "mdadm: Fail create md0 when usin"..., 74mdadm: Fail create md0 when using /sys/module/md_mod/parameters/new_array
) = 74
unlink("/run/mdadm/creating-md0")       = 0

Dado que o metadispositivo foi criado com sucesso, o que Fail createsignifica a terminologia neste contexto?

O egrepcomando foi preterido em favor do grep -E.

A definição POSIX paragrep inclui a seguinte nota,

Isso grepfoi aprimorado de maneira compatível com versões anteriores para fornecer a funcionalidade exata do histórico egrepe dos fgrepcomandos também. Era a intenção clara dos desenvolvedores de padrões consolidar os três greps em um único comando.

Os comandos antigos egrepe fgrepprovavelmente serão suportados por muitos anos como extensões de implementação, permitindo que aplicativos históricos operem sem modificações.

No entanto, não há entrada de definição de comando POSIX para egrepsi mesma.

Esta seção confirma que egrepé um comando POSIX reconhecido (mesmo que seja obsoleto), ou apenas observa que o comando existia e deve ser (diferente do deve ser) suportado no futuro próximo?

Tentando colocar de outra forma, qual é a situação egrepem relação ao POSIX?

A página man do GNU findadverte claramente que usar -deleteimplica -depth. No entanto, não consigo encontrar nenhuma explicação para este requisito:

-deleteDeletar arquivos; true se a remoção for bem-sucedida. Se a remoção falhar, uma mensagem de erro será emitida. […] O uso de -deleteliga automaticamente a -depthopção.

find --version
find (GNU findutils) 4.8.0

Isso é implicitamente um passeio pós-ordem:

find /path -type f -delete

Mas este é um passeio de pré-encomenda, o método usual de travessia para find:

find /path -type f -exec rm -f {} +

Se eu quiser usar -prune, não posso usar -deletee, em vez disso, devo usar o mais complicado -exec rm {} +, mas o efeito líquido parece o mesmo.

A -deleteação não remove diretórios, então por que find -deleteprecisa implicar -depth?

Comprime rsync -zblocos de cada arquivo sem considerar o arquivo anterior ou o dicionário de compactação é redefinido para cada arquivo para que seja tratado de forma independente?

Como exemplo, considere um arquivo compactável one.txte sua cópia idêntica sendo transferida para um servidor remoto, onde nenhum arquivo ainda existe:

cp -p one.txt two.txt
rsync -az one.txt two.txt remote:

A zlibcamada de compactação trata one.txte two.txtindependentemente, ou a transferência de dados nesse nível é simplesmente um fluxo contínuo, então ele terá aprendido um dicionário de compactação útil para one.txto qual pode aplicar two.txt?

Alternativamente, eu entendi completamente mal o zlibalgoritmo de compressão, de tal forma que (por exemplo) o dicionário é sempre redefinido para cada novo bloco?

Eu tentei olhar para a rsyncsaída de depuração, rsync -avvvvz --debug=IO1,IO2,IO3,IO4 --msgs2stderrmas não consigo ver nada que se relacione especificamente com a camada de compressão.

_{(Isso está seguindo um tópico de comentários em uma resposta minha no ServerFault.)}

Eu tenho vários sistemas baseados em Debian que são copiados regularmente usando arquivos rsync. Por vários motivos, tive que implantar um pequeno servidor CentOS 7 e quero adicioná-lo ao meu agendamento de backup. Não pode ser feito backup usando rsync sobre ssh; em vez disso, preciso usar o daemon rsync.

O CentOS tem o SELinux habilitado no modo de imposição, então isso me colocou em uma curva de aprendizado íngreme.

A rsyncdseção de configuração (simplificada)

[root]
    comment = Filesystem
    path = /
    exclude = /proc/*** /run/*** /sys/*** [...]
    read only = yes
    list = yes
    uid = root
    secrets file = [...]
    ignore errors = no
    ignore nonreadable = no
    refuse options = delete

Eu acredito que o processo está rotulado corretamente:

ps -eZ | grep rsync
system_u:system_r:rsync_t:s0    26020 ?        00:00:00 rsync

Inicialmente, a tentativa de backup por meio do rsyncdaemon falhou com todos os tipos de erros de permissão que atribuí aos rótulos do SELinux. Cavando mais, encontrei uma referência a uma política SELinux que permite que o rsyncdaemon exporte todos os arquivos somente leitura:

setsebool -P rsync_export_all_ro 1

Isso resulta neste conjunto

getsebool -a | grep '^rsync'
rsync_anon_write --> off
rsync_client --> off
rsync_export_all_ro --> on
rsync_full_access --> off

Infelizmente, isso ainda não me dá acesso a todos os arquivos no sistema. Especificamente, tenho alguns arquivos /var/spool/postfix/privateque são ilegíveis:

rsync: readlink_stat("/var/spool/postfix/private/defer" (in root)) failed: Permission denied (13)
rsync: readlink_stat("/var/spool/postfix/private/trace" (in root)) failed: Permission denied (13)
rsync: readlink_stat("/var/spool/postfix/private/verify" (in root)) failed: Permission denied (13)
rsync: readlink_stat("/var/spool/postfix/private/proxymap" (in root)) failed: Permission denied (13)
...

Uma entrada de exemplo relacionada a /var/spool/postfix/privatefrom audit2why -asegue. Observe que nenhuma das entradas faz referência a rsync_export_all_ro:

type=AVC msg=audit(1565118203.332:21775): avc:  denied  { getattr } for  pid=26597 comm="rsync" path="/var/spool/postfix/private/scache" dev="dm-0" ino=9148374 scontext=system_u:system_r:rsync_t:s0 tcontext=system_u:object_r:postfix_private_t:s0 tclass=sock_file permissive=0
        Was caused by:
        The boolean rsync_full_access was set incorrectly.
        Description:
        Allow rsync to full access

        Allow access by executing:
        # setsebool -P rsync_full_access 1

Não entendo por que há uma referência a rsync_full_access(que não quero definir e não deveria ser acionada de qualquer maneira), mas nenhuma a rsync_export_all_ro.

No interesse de obter um backup completo, como posso adicionar esta árvore de diretórios ao conjunto de arquivos que podem ser exportados pelo rsyncdaemon? (E para que essa mudança seja persistente nas reinicializações.)

Considere duas expressões condicionais expr1e expr2, por exemplo $i -eq $je $k -eq $l. Podemos escrever isso de bashvárias maneiras. Aqui estão duas possibilidades

[[ expr1 || expr2 ]]

[[ expr1 ]] || [[ expr2 ]]

Tenho certeza de que vi recomendações aqui de que o segundo deve ser preferido, mas não consigo encontrar evidências para apoiar isso.

Aqui está um script de exemplo que parece demonstrar que não há diferença:

for i in 0 1
do
  for j in 0 1
  do
    for k in 0 1
    do
      for l in 0 1
      do
        if [[ $i -eq $j || $k -eq $l ]]; then printf "1-yes\t"; else printf "1-no\t"; fi
        if [[ $i -eq $j ]] || [[ $k -eq $l ]]; then printf "2-yes\n"; else printf "2-no\n"; fi
      done
    done
  done
done

e saída mostrando que ambas as construções de condição produzem o mesmo resultado:

1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-no    2-no
1-no    2-no
1-yes   2-yes
1-yes   2-yes
1-no    2-no
1-no    2-no
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes
1-yes   2-yes

Existe algum benefício em usar uma construção sobre a outra?

Para pontos de bônus, a mesma pergunta, mas generalizando para várias condições usando ||e &&. Por exemplo, [[ expr1 && expr2 || expr3 ]].

Eu tenho uma variável de script de shell, que atualmente é definida assim:

tsource=/backup/%HOST%/%SHARE%/%PERIOD%

Eu quero combinar este modelo com outra variável, que pode ter um valor como este:

psource=/backup/somehost/someshare/monthly.1

Meu objetivo é gerar as seguintes atribuições para que eu possa usá-las para uma substituição posteriormente no script:

vars[HOST]=somehost
vars[SHARE]=someshare
vars[PERIOD]=monthly.1

Devo salientar que o usuário pode substituir esses dois valores e podemos acabar com formas diferentes (mas ainda correspondentes), o que significa que uma simples "divisão em /" (ou mesmo "divisão na pontuação") é insuficiente:

tsource=/backup/%PERIOD/where/%HOST%-%SHARE%
psource=/backup/monthly.1/where/somehost-someshare

A intenção é poder analisar $psourcecom base no modelo fornecido pelo $tsource. Como é um software utilitário, eu realmente não me importo se o usuário tentar quebrá-lo - ele falhará mais tarde se parâmetros insuficientes ou inválidos forem fornecidos.

Olhando para possíveis soluções, acho que algo como sscanfpoderia ser útil aqui, que é uma ferramenta que está indiretamente disponível para mim. Eu posso facilmente manipular $tsourcepara extrair HOST, SHAREe PERIOD, e derivar um sscanfmodelo:

grep -Po "(?<=%)[[:upper:]]+(?=%)" <<<"$tsource"           # "HOST" "SHARE" "PERIOD"
tscanf=$(sed -re 's/%[[:upper:]]+%/%s/g' <<<"$tsource")    # "/backup/%s/%s/%s"

Isso me permitiria aplicar o modelo em Perl, como este exemplo:

perl -MString::Scanf -e '
    $psource = "/backup/somehost/someshare/monthly.1";
    $tscanf = "/backup/%s/%s/%s";
    ($host, $source, $period) = sscanf($tscanf, $psource);
    print "host=$host, share=$share, period=$period\n"
'
# "host=somehost, share=someshare, period=monthly.1"

(Se eu fosse mergulhar no Perl, provavelmente faria a reescrita e sscanfgeração do modelo na parte do Perl também, mas vamos estacionar isso por enquanto.)

No entanto, é um pouco difícil escrever um script de shell que precisa do perl.

Existe uma solução alternativa (melhor) que me permita mapear valores de uma string para rótulos bastante arbitrários em um modelo, que não envolva um mergulho rápido no Perl?

Debian 9 (stretch) com ZFS 0.7.12 no kernel 4.15.18-9-pve. Eu tenho um pool ZFS com um conjunto de dados:

zfs list
NAME                       USED  AVAIL  REFER  MOUNTPOINT
rpool                     2.81T  39.3T   120K  /rpool
rpool/data                2.81T  39.3T    96K  /rpool/data
rpool/data/vm-101-disk-0  7.74G  39.3T  7.74G  -
rpool/data/vm-102-disk-0  5.62G  39.3T  5.62G  -
rpool/data/vm-102-disk-1  2.82T  39.3T  2.82T  -

mount -t zfs
/rpool on /rpool type zfs (rw,xattr,noacl)
/rpool/data on /rpool/data type zfs (rw,xattr,noacl)

Por um curto período, eu também tinha um conjunto de dados em rpool/store, com alguns arquivos e diretórios armazenados, /rpool/storemas costumava zfs destroy rpool/storeremovê-lo.

Agora descubro que tenho uma cópia da estrutura de diretórios ainda em /rpool/store:

ls /rpool/store/
dump  images  private  template

Tentei removê-los, mas sem sucesso:

rm -rf /rpool/store
ls /rpool/store/
dump  images  private  template

Se eu ignorar essa situação e tentar recriar meu storeconjunto de dados, recebo este erro:

zfs create rpool/store
cannot mount '/rpool/store': directory is not empty
filesystem successfully created, but not mounted

Como removo os arquivos e diretórios em /rpool/store?

Considere o arquivo simplificado

AAA
BBB
CCC1
DDD
EEE
CCC2
DDD
FFF
GGG
CCC3
HHH

Eu posso escolher o intervalo EEEcomFFF

sed -n '/EEE/,/FFF/p'

Suponha que eu queira imprimir qualquer linha contendo, Cmas apenas dentro do intervalo correspondente. Eu posso canalizar o resultado de sedatravésgrep

sed -n '/EEE/,/FFF/p' | grep 'C'

Eu também poderia fazer o intervalo e combinar em um pequeno awkscript (ou perl, python, etc.). Mas como eu faria isso usando apenas uma invocação de sed?

Em resposta a uma pergunta diferente, eu queria usar uma estrutura muito parecida com esta para encontrar arquivos que aparecem em list2que não aparecem em list1:

( cd dir1 && find . -type f -print0 ) | sort -z > list1
( cd dir2 && find . -type f -print0 ) | sort -z > list2
comm -13 list1 list2

No entanto, bati em uma parede de tijolos porque minha versão de commnão pode lidar com registros terminados em NULL. (Alguns antecedentes: estou passando uma lista computada para rm, então, particularmente, quero ser capaz de lidar com nomes de arquivo que possam conter uma nova linha incorporada.)

Se você quer um exemplo fácil de trabalhar, tente isso

mkdir dir1 dir2
touch dir1/{a,b,c} dir2/{a,c,d}
( cd dir1 && find . -type f ) | sort > list1
( cd dir2 && find . -type f ) | sort > list2
comm -13 list1 list2

Sem linhas terminadas em NULL, a saída aqui é o único elemento ./dque aparece apenas em list2.

Gostaria de poder usar find ... -print0 | sort -zpara gerar as listas.

Como posso reimplementar melhor um equivalente para commque produza os registros terminados em NULL que aparecem, list2mas que não aparecem list1?