exclusão de linha no local sed no sistema de arquivos completo?

Devido a um erro no aplicativo ainda não diagnosticado, tenho várias centenas de servidores com um disco completo. Há um arquivo que foi preenchido com linhas duplicadas - não um arquivo de log, mas um arquivo de ambiente do usuário com definições de variáveis ​​(portanto, não posso simplesmente excluir o arquivo).

Eu escrevi um sedcomando simples para verificar as linhas adicionadas erroneamente e excluí-las, e testei em uma cópia local do arquivo. Funcionou como pretendido.

No entanto, quando tentei no servidor com o disco completo, recebi aproximadamente o seguinte erro (é da memória, não copia e cola):

sed: couldn't flush /path/to/file/sed8923ABC: No space left on deviceServerHostname

Claro, eu sei que não resta espaço. É por isso que estou tentando excluir coisas! (O sedcomando que estou usando reduzirá um arquivo de mais de 4000 linhas para cerca de 90 linhas.)

Meu sedcomando é apenassed -i '/myregex/d' /path/to/file/filename

Existe uma maneira de aplicar este comando apesar do disco completo?

(Ele deve ser automatizado, pois preciso aplicá-lo a várias centenas de servidores como uma solução rápida.)

_{(Obviamente, o bug do aplicativo precisa ser diagnosticado, mas, enquanto isso, os servidores não estão funcionando corretamente ...)}

Atualização: a situação que enfrentei foi resolvida excluindo outra coisa que descobri que poderia excluir, mas ainda assim gostaria de responder a essa pergunta, que seria útil no futuro e para outras pessoas.

/tmpé um não-go; está no mesmo sistema de arquivos.

Antes de liberar espaço em disco, testei e descobri que era possível excluir as linhas viabrindo o arquivo e executando :g/myregex/de, em seguida, salve as alterações com êxito :wq. Parece que deve ser possível automatizar isso, sem recorrer a um sistema de arquivos separado para armazenar um arquivo temporário .... (?)

A -iopção realmente não substitui o arquivo original. Ele cria um novo arquivo com a saída e o renomeia para o nome do arquivo original. Como você não tem espaço no sistema de arquivos para esse novo arquivo, ele falha.

Você precisará fazer isso sozinho em seu script, mas crie o novo arquivo em um sistema de arquivos diferente.

Além disso, se você estiver apenas excluindo linhas que correspondem a uma regexp, poderá usar em grepvez de sed.

grep -v 'myregex' /path/to/filename > /tmp/filename && mv /tmp/filename /path/to/filename

Em geral, raramente é possível que os programas usem o mesmo arquivo que a entrada e a saída - assim que começar a gravar no arquivo, a parte do programa que está lendo o arquivo não verá mais o conteúdo original. Portanto, ele precisa copiar o arquivo original em algum lugar primeiro ou gravar em um novo arquivo e renomeá-lo quando terminar.

Se você não quiser usar um arquivo temporário, tente armazenar em cache o conteúdo do arquivo na memória:

file=$(< /path/to/filename)
echo "$file" | grep -v 'myregex' > /path/to/filename

É assim que sedfunciona. Se usado com -i(edição no local) sedcria um arquivo temporário com o novo conteúdo do arquivo processado. Quando concluído sed, substitui o arquivo de trabalho atual pelo temporário. O utilitário não edita o arquivo no local . Esse é exatamente o comportamento de todo editor.

É como se você executasse a seguinte tarefa em um shell:

sed 'whatever' file >tmp_file
mv tmp_file file

Neste ponto sed, tenta liberar os dados em buffer no arquivo mencionado na mensagem de erro com a fflush()chamada do sistema:

Para fluxos de saída, fflush()força uma gravação de todos os dados em buffer no espaço do usuário para a saída especificada ou atualiza o fluxo por meio da função de gravação subjacente do fluxo.

Para o seu problema, vejo uma solução na montagem de um sistema de arquivos separado (por exemplo tmpfs, a , se você tiver memória suficiente ou um dispositivo de armazenamento externo) e mova alguns arquivos para lá, processe-os para lá e mova-os de volta.

Desde a publicação desta pergunta, aprendi que exé um programa compatível com POSIX. É quase universalmente vinculado vim, mas de qualquer forma, o seguinte é (eu acho) um ponto-chave exem relação aos sistemas de arquivos (retirado da especificação POSIX):

Esta seção usa o termo buffer de edição para descrever o texto de trabalho atual. Nenhuma implementação específica está implícita neste termo. Todas as alterações de edição são executadas no buffer de edição e nenhuma alteração deve afetar nenhum arquivo até que um comando do editor grave o arquivo.

"... afetará qualquer arquivo ..." Acredito que colocar algo no sistema de arquivos (até mesmo um arquivo temporário) contaria como "afetando qualquer arquivo". Talvez?*

Um estudo cuidadoso das especificações POSIX paraex indicar algumas "dicas" sobre seu uso portátil pretendido, quando comparado aos usos comuns de script exencontrados on-line (que estão repletos de vimcomandos específicos).

1. A implementação +cmdé opcional de acordo com o POSIX.
2. Permitir várias -copções também é opcional.
3. O comando global :g"come" tudo até a próxima nova linha não escapada (e, portanto, executa-o após cada correspondência encontrada para a regex em vez de uma vez no final). Portanto, -c 'g/regex/d | x'apenas exclui uma instância e sai do arquivo.

Portanto, de acordo com o que pesquisei, o método compatível com POSIX para editar no local um arquivo em um sistema de arquivos completo para excluir todas as linhas correspondentes a um regex específico é:

ex -sc 'g/myregex/d
x' /path/to/file/filename

Isso deve funcionar, desde que você tenha memória suficiente para carregar o arquivo em um buffer.

_{* Se você encontrar algo que indique o contrário, mencione nos comentários.}

Use o cachimbo, Luke!

Ler arquivo | filtro | Escreva de volta

sed 's/PATTERN//' BIGFILE | dd of=BIGFILE conv=notrunc

nesse caso sed, não cria um novo arquivo e apenas envia a saída canalizada para a ddqual abre o mesmo arquivo . Claro que se pode usar grepem casos particulares

grep -v 'PATTERN' BIGFILE | dd of=BIGFILE conv=notrunc

depois trunque o restante.

dd if=/dev/null of=BIGFILE seek=1 bs=BYTES_OF_SED_OUTPUT

Conforme observado em outras respostas, sed -ifunciona copiando o arquivo para um novo arquivo no mesmo diretório , fazendo alterações no processo e movendo o novo arquivo sobre o original. É por isso que não funciona.  ed(o editor de linha original) funciona de maneira um pouco semelhante, mas, da última vez que verifiquei, ele é usado /tmppara o arquivo inicial. Se você /tmpestiver em um sistema de arquivos diferente do que está cheio, edpode fazer o trabalho por você.

Tente isso (no prompt do shell interativo):

$ ed / caminho / para / arquivo / nome do arquivo
P
g / myregex / d
W
q

O P(que é um P maiúsculo ) não é estritamente necessário. Ativa a solicitação; sem ele, você está trabalhando no escuro e algumas pessoas acham isso desconcertante. O we qsão w rito e q uit.

edé notório por diagnósticos enigmáticos. Se a qualquer momento exibir algo diferente do prompt (que é *) ou algo que seja claramente uma confirmação de operação bem-sucedida ( especialmente se contiver a ?), não escreva o arquivo (com w). Apenas saia ( q). Se não deixar você sair, tente dizer qnovamente.

Se o seu /tmpdiretório estiver no sistema de arquivos cheio (ou se o sistema de arquivos estiver cheio também), tente encontrar algum espaço em algum lugar. o caos mencionado na montagem de um tmpfs ou de um dispositivo de armazenamento externo (por exemplo, uma unidade flash); mas, se você tiver vários sistemas de arquivos e eles não estiverem todos cheios, poderá simplesmente usar um dos outros existentes. o caos sugere copiar o (s) arquivo (s) para o outro sistema de arquivos, editando-o (com sed) e copiando-o de volta. Nesse ponto, essa pode ser a solução mais simples. Mas uma alternativa seria criar um diretório gravável em um sistema de arquivos que tenha algum espaço livre, definir a variável de ambiente TMPDIRpara apontar para esse diretório e depois executar ed. (Divulgação: não tenho certeza se isso vai funcionar, mas não pode doer.)

Depois de edtrabalhar, você pode automatizar isso fazendo

nome do arquivo ed << EOF
g / myregex / d
W
q
EOF

em um script. Ou , como sugerido por don_crissti.printf '%s\n' 'g/myregex/d' w q | ed -s filename

Você pode truncar o arquivo com bastante facilidade se conseguir obter a contagem de bytes para o deslocamento e suas linhas ocorrerem desde o ponto inicial até o final.

o=$(sed -ne'/regex/q;p' <file|wc -c)
dd if=/dev/null of=file bs="$o" seek=1

Ou então, se você ${TMPDIR:-/tmp}estiver em outro sistema de arquivos, talvez:

{   cut -c2- | sed "$script" >file
} <file <<FILE
$(paste /dev/null -)
FILE

Porque (a maioria) os shells colocam seus documentos aqui em um arquivo temporário excluído. É perfeitamente seguro, desde que o <<FILEdescritor seja mantido do início ao fim e ${TMPDIR:-/tmp}tenha o espaço necessário.

Os shells que não usam arquivos temporários usam pipes e, portanto, não são seguros para uso dessa maneira. Estes escudos são tipicamente ashderivados como busybox, dash, BSD sh- zsh, bash, kshe o shell Bourne, no entanto, todos os arquivos de utilização de trabalho temporário.

aparentemente, eu escrevi um pequeno programa de shell em julho passado para fazer algo muito parecido com isto

Se /tmpnão for viável, desde que você possa ajustar o arquivo na memória, algo como ...

sed 'H;$!d;x' <file | { read v &&
sed "$script" >file;}

... como um caso geral, pelo menos, garantiria que o arquivo fosse totalmente armazenado em buffer pelo primeiro sedprocesso antes de tentar truncar o arquivo de entrada / saída.

Uma solução mais direcionada - e eficiente - pode ser:

sed '/regex/!H;$!d;x' <file|{ read v && cat >file;}

... porque não incomodaria as linhas de buffer que você pretendia excluir de qualquer maneira.

Um teste do caso geral:

{   nums=/tmp/nums
    seq 1000000 >$nums
    ls -lh "$nums"
    wc -l  "$nums"
    sed 'H;$!d;x' <$nums | { read script &&  ### read always gets a blank
    sed "$script" >$nums;}
    wc -l  "$nums"
    ls -lh "$nums"
}

-rw-r--r-- 1 mikeserv mikeserv 6.6M Dec 22 20:26 /tmp/nums
1000000 /tmp/nums
1000000 /tmp/nums
-rw-r--r-- 1 mikeserv mikeserv 6.6M Dec 22 20:26 /tmp/nums

Esta resposta empresta idéias dessa outra resposta e dessa outra resposta, mas se baseia nelas, criando uma resposta mais aplicável em geral:

num_bytes = $ (sed '/ myregex / d' / caminho / para / arquivo / nome do arquivo | wc -c)
sed '/ myregex / d' / caminho / para / arquivo / nome do arquivo 1 <> / caminho / para / arquivo / nome do arquivo 
dd se = / dev / null de = / caminho / para / arquivo / nome do arquivo bs = "$ num_bytes" = 1

A primeira linha executa o sedcomando com a saída gravada na saída padrão (e não em um arquivo); especificamente, a um tubo wcpara contar os caracteres. A segunda linha também executa o sedcomando com a saída gravada na saída padrão, que, nesse caso, é redirecionada para o arquivo de entrada no modo de substituição de leitura / gravação (sem truncamento), discutido aqui . Isso é algo perigoso de se fazer; é seguro somente quando o comando filter nunca aumenta a quantidade de dados (texto); ou seja, para cada n bytes que lê, ele grava n ou menos bytes. Isso é verdade, é claro, para o sed '/myregex/d'comando; para cada linha que lê, escreve exatamente a mesma linha, ou nada. (Outros exemplos:s/foo/fu/ou s/foo/bar/seria seguro, mas s/fu/foo/e s/foo/foobar/não o faria.)

Por exemplo:

$ cat filename
It was
a dark and stormy night.
$ sed '/was/d' filename 1<> filename
$ cat filename
a dark and stormy night.
night.

porque esses 32 bytes de dados:

I  t     w  a  s \n  a     d  a  r  k     a  n  d     s  t  o  r  m  y     n  i  g  h  t  . \n

foi sobrescrito com esses 25 caracteres:

a     d  a  r  k     a  n  d     s  t  o  r  m  y     n  i  g  h  t  . \n

deixando os sete bytes night.\nrestantes no final.

Por fim, o ddcomando procura o final dos novos dados limpos (byte 25 neste exemplo) e remove o restante do arquivo; isto é, trunca o arquivo nesse ponto.

Se, por qualquer motivo, o 1<>truque não funcionar, você poderá

sed '/ myregex / d' / caminho / para / arquivo / nome do arquivo | dd de = / caminho / para / arquivo / nome do arquivo conv = notrunc

Além disso, observe que, enquanto tudo o que você está fazendo é remover linhas, tudo o que você precisa é grep -v myregex(conforme indicado por Barmar ).

sed -i 'd' / caminho / para / arquivo / nome do arquivo