All perguntas(unix)

Estou usando uma imagem docker como base para meu próprio desenvolvimento que adiciona o repositório jessie backports em seu Dockerfile e usa isso para instalar uma dependência. Esta imagem usa o seguinte comando para adicionar o repositório:

echo "deb http://ftp.debian.org/debian jessie-backports main" >> /etc/apt/sources.list

O problema é que a busca de pacotes do repositório backports agora falha com o seguinte erro (isso costumava funcionar anteriormente):

W: Failed to fetch
http://ftp.debian.org/debian/dists/jessie-backports/main/binary-amd64/Packages
404  Not Found

W: Failed to fetch
http://deb.debian.org/debian/dists/jessie-updates/main/binary-amd64/Packages
 404  Not Found

Eu olhei nesse servidor e esses caminhos realmente não estão presentes lá.

Eu tentei descobrir no site de backports do Debian se esse repositório específico ainda deveria estar disponível, e não encontrei nenhuma indicação de que isso estava obsoleto ou algo assim.

Este é um problema temporário com o repositório ou o repositório jessie-backports não está mais disponível? E se isso não for um problema temporário, quais opções eu tenho para usar este ou um repositório equivalente sem atualizar para a versão estável do Debian mais recente?

Eu li o que é multi-user.target e a documentação do systemd , que afirma que o multi-user.target é um destino especial. Além disso, muitos dos exemplos do systemd contêm essa linha.

1. Por que tantos serviços de exemplo contêm essa linha?
2. O que aconteceria se eles não contivessem WantedBy=multi-user.target?
3. Você poderia me dar um exemplo de quando seria realmente aconselhável não incluir essa linha em uma definição de arquivo de serviço?
4. Na mesma linha, quando é uma boa ideia manter essa linha?

Eu gerei chaves usando GPG, executando o seguinte comando

gpg --gen-key

Agora preciso exportar o par de chaves para um arquivo; ou seja, chaves privadas e públicas para private.pgpe public.pgp, respectivamente. Como eu faço isso?

Quando corro systemctl status, chego State: degradedao topo,

● x230
    State: degraded
     Jobs: 0 queued
   Failed: 1 units
    Since: Wed 2018-05-30 17:09:49 CDT; 3 days ago
  ....

O que está acontecendo e como faço para corrigir isso?

$ ls -l /tmp/test/my\ dir/
total 0

Eu queria saber por que as seguintes maneiras de executar o comando acima falham ou são bem-sucedidas?

$ abc='ls -l "/tmp/test/my dir"'

$ $abc
ls: cannot access '"/tmp/test/my': No such file or directory
ls: cannot access 'dir"': No such file or directory

$ "$abc"
bash: ls -l "/tmp/test/my dir": No such file or directory

$ bash -c $abc
'my dir'

$ bash -c "$abc"
total 0

$ eval $abc
total 0

$ eval "$abc"
total 0

Estou tentando entender o conceito de arquivos especiais no Linux. No entanto, ter um arquivo especial /devparece bobo quando sua função pode ser implementada por um punhado de linhas em C, pelo que sei.

Além disso, você pode usá-lo praticamente da mesma maneira, ou seja, canalizando em nullvez de redirecionar para /dev/null. Existe uma razão específica para tê-lo como um arquivo? Torná-lo um arquivo não causa muitos outros problemas, como muitos programas acessando o mesmo arquivo?

Estou procurando uma maneira de simplesmente imprimir as últimas linhas X de um serviço systemctl no Debian. Gostaria de instalar este código em um script, que usa as entradas de log impressas e mais recentes. Encontrei este post, mas não consegui modificá-lo para meus propósitos.

Atualmente estou usando este código, que está apenas me dando um pequeno trecho dos arquivos de log:

journalctl --unit=my.service --since "1 hour ago" -p err

Para dar um exemplo de como deve ser o resultado, basta digitar o comando acima para qualquer serviço e rolar até o final do log. Em seguida, copie as últimas 300 linhas começando de baixo.

Minha ideia é usar egrep ex. egrep -m 700 .mas não tive sorte desde agora.

Eu tenho alguns arquivos de log longos. Posso ver as últimas linhas com tail -n 50 file.txt, mas às vezes preciso editar essas últimas linhas.

Como faço para pular direto para o final de um arquivo ao visualizá-lo com nano?

Depois de descobrir que vários comandos comuns (como read) são na verdade internos do Bash (e ao executá-los no prompt, na verdade, estou executando um script de shell de duas linhas que apenas encaminha para o interno), eu estava procurando ver se o mesmo é verdadeiro para truee false.

Bem, eles são definitivamente binários.

sh-4.2$ which true
/usr/bin/true
sh-4.2$ which false
/usr/bin/false
sh-4.2$ file /usr/bin/true
/usr/bin/true: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=2697339d3c19235
06e10af65aa3120b12295277e, stripped
sh-4.2$ file /usr/bin/false
/usr/bin/false: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=b160fa513fcc13
537d7293f05e40444fe5843640, stripped
sh-4.2$

No entanto, o que mais me surpreendeu foi o tamanho. Eu esperava que eles tivessem apenas alguns bytes cada, pois trueé basicamente apenas exit 0e falseé exit 1.

sh-4.2$ true
sh-4.2$ echo $?
0
sh-4.2$ false
sh-4.2$ echo $?
1
sh-4.2$

No entanto, descobri, para minha surpresa, que ambos os arquivos têm mais de 28 KB de tamanho.

sh-4.2$ stat /usr/bin/true
  File: '/usr/bin/true'
  Size: 28920           Blocks: 64         IO Block: 4096   regular file
Device: fd2ch/64812d    Inode: 530320      Links: 1                     
Access: (0755/-rwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2018-01-25 19:46:32.703463708 +0000
Modify: 2016-06-30 09:44:27.000000000 +0100
Change: 2017-12-22 09:43:17.447563336 +0000
 Birth: -
sh-4.2$ stat /usr/bin/false
  File: '/usr/bin/false'
  Size: 28920           Blocks: 64         IO Block: 4096   regular file
Device: fd2ch/64812d    Inode: 530697      Links: 1                     
Access: (0755/-rwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2018-01-25 20:06:27.210764704 +0000
Modify: 2016-06-30 09:44:27.000000000 +0100
Change: 2017-12-22 09:43:18.148561245 +0000
 Birth: -
sh-4.2$

Então, minha pergunta é: por que eles são tão grandes? O que há no executável além do código de retorno?

PS: Estou usando o RHEL 7.4

Eu tenho um enorme (70 GB), uma linha , arquivo de texto e quero substituir uma string (token) nele. Desejo substituir o token <unk>por outro token fictício ( emissão de luva ).

eu tentei sed:

sed 's/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

mas o arquivo de saída corpus.txt.newtem zero bytes!

Eu também tentei usar perl:

perl -pe 's/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

mas recebi um erro de falta de memória.

Para arquivos menores, ambos os comandos acima funcionam.

Como posso substituir uma string como um arquivo? Esta é uma questão relacionada, mas nenhuma das respostas funcionou para mim.

Editar : Que tal dividir o arquivo em pedaços de 10 GB (ou o que for) cada um e aplicar sedem cada um deles e depois mesclá-los com cat? Isso faz sentido? Existe uma solução mais elegante?