sed la cancellazione della riga sul posto sul filesystem completo?

A causa di un bug dell'applicazione non ancora diagnosticato, ho diverse centinaia di server con un disco completo. C'è un file che è stato riempito con righe duplicate, non un file di registro, ma un file di ambiente utente con definizioni variabili (quindi non posso semplicemente eliminare il file).

Ho scritto un semplice sedcomando per verificare la presenza di righe erroneamente aggiunte ed eliminarle, e l'ho testato su una copia locale del file. Ha funzionato come previsto.

Tuttavia, quando l'ho provato sul server con l'intero disco, ho ottenuto approssimativamente il seguente errore (è dalla memoria, non dalla copia e incolla):

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

Certo, so che non c'è più spazio. Ecco perché sto cercando di eliminare cose! (Il sedcomando che sto usando ridurrà un file di oltre 4000 righe a circa 90 righe.)

Il mio sedcomando è giustosed -i '/myregex/d' /path/to/file/filename

C'è un modo per applicare questo comando nonostante l'intero disco?

(Deve essere automatizzato, poiché devo applicarlo a diverse centinaia di server come soluzione rapida.)

_{(Ovviamente il bug dell'applicazione deve essere diagnosticato, ma nel frattempo i server non funzionano correttamente ....)}

Aggiornamento: la situazione che ho affrontato è stata risolta eliminando qualcos'altro che ho scoperto di poter eliminare, ma mi piacerebbe comunque la risposta a questa domanda, che sarebbe utile in futuro e per le altre persone.

/tmpè un non-andare; è sullo stesso filesystem.

Prima di liberare spazio su disco, ho eseguito il test e ho scoperto che potevo eliminare le righe viaprendo il file ed eseguendolo, :g/myregex/dquindi salvando correttamente le modifiche con :wq. Sembra che dovrebbe essere possibile automatizzare questo, senza ricorrere a un filesystem separato per contenere un file temporaneo .... (?)

L' -iopzione non sovrascrive realmente il file originale. Crea un nuovo file con l'output, quindi lo rinomina con il nome file originale. Dato che non hai spazio sul filesystem per questo nuovo file, fallisce.

Dovrai farlo tu stesso nel tuo script, ma crea il nuovo file su un file system diverso.

Inoltre, se stai semplicemente eliminando le righe che corrispondono a una regexp, puoi usare grepinvece di sed.

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

In generale, raramente è possibile che i programmi utilizzino lo stesso file di input e output - non appena inizia a scrivere sul file, la parte del programma che legge dal file non vedrà più il contenuto originale. Quindi deve prima copiare il file originale da qualche parte, oppure scrivere in un nuovo file e rinominarlo al termine.

Se non si desidera utilizzare un file temporaneo, è possibile provare a memorizzare nella cache il contenuto del file:

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

sedFunziona così . Se utilizzato con -i(modifica sul posto) sedcrea un file temporaneo con i nuovi contenuti del file elaborato. Al termine sed, sostituisce il file di lavoro corrente con quello temporaneo. L'utilità non modifica il file sul posto . Questo è esattamente il comportamento di ogni editore.

È come eseguire la seguente attività in una shell:

sed 'whatever' file >tmp_file
mv tmp_file file

A questo punto sed, tenta di scaricare i dati bufferizzati nel file indicato nel messaggio di errore con la fflush()chiamata di sistema:

Per i flussi di output, fflush()impone una scrittura di tutti i dati bufferizzati nello spazio utente per l'output dato o il flusso di aggiornamento tramite la funzione di scrittura sottostante del flusso.

Per il tuo problema, vedo una soluzione nel montare un filesystem separato (ad esempio a tmpfs, se hai memoria sufficiente o un dispositivo di archiviazione esterno) e spostare alcuni file lì, elaborarli lì e spostarli indietro.

Da quando ho pubblicato questa domanda ho imparato che exè un programma conforme a POSIX. È quasi universalmente collegato a vim, ma in entrambi i casi, il seguente è (penso) un punto chiave exin relazione ai filesystem (tratto dalla specifica POSIX):

Questa sezione utilizza il termine modifica buffer per descrivere il testo di lavoro corrente. Nessuna specifica implementazione è implicita da questo termine. Tutte le modifiche apportate alla modifica vengono eseguite sul buffer di modifica e nessuna modifica deve influire su alcun file fino a quando un comando dell'editor non scrive il file.

"... interesserà qualsiasi file ..." Credo che inserire qualcosa nel filesystem (per niente, anche un file temporaneo) significherebbe "influenzare qualsiasi file". Può essere?*

Attento studio delle specifiche POSIX perex indicare alcuni "gotchas" circa il suo uso portatile previsto rispetto agli usi comuni con script di extrovati online (che sono disseminati di vimcomandi specifici).

1. L'implementazione +cmdè facoltativa secondo POSIX.
2. Consentire più -copzioni è anche facoltativo.
3. Il comando globale :g"mangia" tutto fino alla nuova riga non salvata (e quindi lo esegue dopo ogni corrispondenza trovata per la regex piuttosto che una volta alla fine). Quindi -c 'g/regex/d | x'elimina solo un'istanza e quindi esce dal file.

Quindi, secondo quanto ho studiato, il metodo conforme a POSIX per la modifica sul posto di un file su un file system completo per eliminare tutte le righe corrispondenti a una regex specifica, è:

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

Questo dovrebbe funzionare a condizione che tu abbia memoria sufficiente per caricare il file in un buffer.

_{* Se trovi qualcosa che indica diversamente, per favore, menzionalo nei commenti.}

Usa la pipa, Luke!

Leggi il file | filtro | rispondere

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

in questo caso sednon crea un nuovo file e invia semplicemente l'output di piping a ddcui si apre lo stesso file . Naturalmente si può usare grepin un caso particolare

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

quindi tronca il rimanente.

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

Come notato in altre risposte, sed -ifunziona copiando il file in un nuovo file nella stessa directory , apportando modifiche nel processo e quindi spostando il nuovo file sull'originale. Ecco perché non funziona.  ed(l'editor di riga originale) funziona in modo un po 'simile, ma, l'ultima volta che ho controllato, lo utilizza /tmpper il file scratch. Se il tuo /tmpè su un filesystem diverso da quello pieno, edpuò fare il lavoro per te.

Prova questo (al tuo prompt della shell interattiva):

$ ed / percorso / in / file / nomefile
P
g / myregex / d
w
q

La P(che è una P maiuscola ) non è strettamente necessaria. Attiva il prompt; senza di essa, stai lavorando nel buio e alcune persone lo trovano sconcertante. L' we qsono w rite e q uit.

edè noto per la diagnostica criptica. Se in qualsiasi momento visualizza qualcosa di diverso dal prompt (che è *) o qualcosa che è chiaramente una conferma del corretto funzionamento ( specialmente se contiene un ?), non scrivere il file (con w). Esci da ( q). Se non ti lascia uscire, prova a qripetere.

Se la tua /tmpdirectory si trova sul filesystem pieno (o anche se il suo filesystem è pieno), prova a trovare spazio da qualche parte. il caos menzionato durante il montaggio di un tmpfs o di un dispositivo di archiviazione esterno (ad esempio un'unità flash); ma, se hai più filesystem e non sono tutti pieni, puoi semplicemente usare uno degli altri esistenti. caos suggerisce di copiare i file nell'altro filesystem, modificandoli lì (con sed) e poi copiandoli di nuovo. A questo punto, questa potrebbe essere la soluzione più semplice. Ma un'alternativa sarebbe quella di creare una directory scrivibile su un filesystem che abbia dello spazio libero, impostare la variabile d'ambiente TMPDIRin modo che punti a quella directory, e quindi eseguire ed. (Rivelazione: non sono sicuro che funzionerà, ma non può far male.)

Una volta che hai iniziato a edlavorare, puoi automatizzare ciò facendo

ed il nome del file << EOF
g / myregex / d
w
q
EOF

in una sceneggiatura. Oppure , come suggerito da don_crissti.printf '%s\n' 'g/myregex/d' w q | ed -s filename

È possibile troncare il file abbastanza facilmente se è possibile ottenere il conteggio dei byte per l'offset e le linee si verificano da un punto iniziale alla fine.

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

Oppure se il tuo ${TMPDIR:-/tmp}è su qualche altro file system forse:

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

Perché (la maggior parte) delle shell inserisce i loro documenti qui in un file temporaneo cancellato. È perfettamente sicuro fintanto che il <<FILEdescrittore viene mantenuto dall'inizio alla fine e ${TMPDIR:-/tmp}ha tutto lo spazio di cui hai bisogno.

Le conchiglie che non usano file temporanei usano pipe, quindi non sono sicure da usare in questo modo. Queste conchiglie sono in genere ashderivati come busybox, dash, BSD sh- zsh, bash, ksh, e la shell Bourne, tuttavia, tutti i file temporanei uso.

a quanto pare ho scritto un piccolo programma di shell lo scorso luglio per fare qualcosa di molto simile

Se /tmpnon è praticabile, basta che tu possa adattare il file in memoria qualcosa come ...

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

... come caso generale garantirebbe almeno che il file fosse completamente bufferizzato dal primo sedprocesso prima di tentare di troncare il file in / out.

Una soluzione più mirata - ed efficace - potrebbe essere:

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

... perché non avrebbe disturbato le linee di buffering che intendevi eliminare comunque.

Un test del caso generale:

{   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

Questa risposta prende in prestito idee da quest'altra risposta e da questa altra risposta ma si basa su di esse, creando una risposta che è più generalmente applicabile:

num_bytes = $ (sed '/ myregex / d' / path / to / file / nomefile | wc -c)
sed '/ myregex / d' / path / to / file / nomefile 1 <> / percorso / in / file / nomefile 
dd se = / dev / null di = / percorso / in / file / nomefile bs = "$ num_bytes" cerca = 1

La prima riga esegue il sedcomando con l'output scritto nell'output standard (e non in un file); in particolare, a una pipa wcper contare i personaggi. La seconda riga esegue anche il sedcomando con l'output scritto nell'output standard, che, in questo caso, viene reindirizzato al file di input in modalità di sovrascrittura in lettura / scrittura (senza troncamento), che viene discusso qui . Questa è una cosa piuttosto pericolosa da fare; è sicuro solo quando il comando di filtro non aumenta mai la quantità di dati (testo); vale a dire, per ogni n byte che legge, scrive n o meno byte. Questo è, ovviamente, vero per il sed '/myregex/d'comando; per ogni riga che legge, scrive esattamente la stessa riga o nulla. (Altri esempi:s/foo/fu/o s/foo/bar/sarebbe sicuro, ma s/fu/foo/e s/foo/foobar/non lo sarebbe.)

Per esempio:

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

perché questi 32 byte di dati:

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

sono stati sovrascritti con questi 25 personaggi:

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

lasciando i sette byte night.\nrimasti alla fine.

Infine, il ddcomando cerca la fine dei nuovi dati cancellati (byte 25 in questo esempio) e rimuove il resto del file; cioè, tronca il file in quel punto.

Se, per qualsiasi motivo, il 1<>trucco non funziona, puoi farlo

sed '/ myregex / d' / path / to / file / nomefile | dd di = / percorso / in / file / nomefile conv = notrunc

Inoltre, nota che, fintanto che tutto ciò che stai facendo è rimuovere le linee, tutto ciò di cui hai bisogno è grep -v myregex(come sottolineato da Barmar ).

sed -i 'd' / path / to / file / nomefile