¿Se eliminó la línea in situ en un sistema de archivos completo?

Debido a un error de aplicación aún no diagnosticado, tengo varios cientos de servidores con un disco lleno. Hay un archivo que se ha llenado con líneas duplicadas, no un archivo de registro, sino un archivo de entorno de usuario con definiciones variables (por lo que no puedo eliminar el archivo).

Escribí un sedcomando simple para verificar las líneas agregadas erróneamente y eliminarlas, y lo probé en una copia local del archivo. Funcionó según lo previsto.

Sin embargo, cuando lo probé en el servidor con el disco lleno, recibí aproximadamente el siguiente error (es de memoria, no copiar y pegar):

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

Por supuesto, sé que no queda espacio. ¡Es por eso que estoy tratando de eliminar cosas! (El sedcomando que estoy usando reducirá un archivo de más de 4000 líneas a aproximadamente 90 líneas).

Mi sedcomando es solosed -i '/myregex/d' /path/to/file/filename

¿Hay alguna manera de aplicar este comando a pesar del disco lleno?

(Debe ser automatizado, ya que necesito aplicarlo a varios cientos de servidores como una solución rápida).

_{(Obviamente, el error de la aplicación debe diagnosticarse, pero mientras tanto los servidores no funcionan correctamente ...)}

Actualización: La situación que enfrenté se resolvió eliminando algo más que descubrí que podía eliminar, pero todavía me gustaría la respuesta a esta pregunta, que sería útil en el futuro y para otras personas.

/tmpes un no-go; Está en el mismo sistema de archivos.

Antes de liberar espacio en el disco, probé y descubrí que podía eliminar las líneas viabriendo el archivo y ejecutándolo :g/myregex/dy luego guardando los cambios con éxito :wq. Parece que debería ser posible automatizar esto, sin recurrir a un sistema de archivos separado para contener un archivo temporal ... (?)

La -iopción realmente no sobrescribe el archivo original. Crea un nuevo archivo con la salida, luego lo renombra al nombre de archivo original. Como no tiene espacio en el sistema de archivos para este nuevo archivo, falla.

Deberá hacerlo usted mismo en su script, pero cree el nuevo archivo en un sistema de archivos diferente.

Además, si solo está eliminando líneas que coinciden con una expresión regular, puede usar en greplugar de sed.

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

En general, rara vez es posible que los programas utilicen el mismo archivo como entrada y salida: tan pronto como comience a escribir en el archivo, la parte del programa que está leyendo el archivo ya no verá el contenido original. Por lo tanto, primero debe copiar el archivo original en algún lugar o escribir en un archivo nuevo y cambiarle el nombre cuando esté listo.

Si no desea utilizar un archivo temporal, puede intentar almacenar en caché el contenido del archivo en la memoria:

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

Así es como sedfunciona. Si se usa con -i(editar en el lugar) sedcrea un archivo temporal con los nuevos contenidos del archivo procesado. Cuando termine sed, reemplaza el archivo de trabajo actual con el archivo temporal. La utilidad no edita el archivo en el lugar . Ese es exactamente el comportamiento de cada editor.

Es como si realizaras la siguiente tarea en un shell:

sed 'whatever' file >tmp_file
mv tmp_file file

En este punto sed, intenta vaciar los datos almacenados en el archivo mencionado en el mensaje de error con la fflush()llamada al sistema:

Para las secuencias de salida, fflush()fuerza una escritura de todos los datos almacenados en el espacio de usuario para la salida dada o la secuencia de actualización a través de la función de escritura subyacente de la secuencia.

Para su problema, veo una solución para montar un sistema de archivos separado (por ejemplo tmpfs, si tiene suficiente memoria o un dispositivo de almacenamiento externo) y mover algunos archivos allí, procesarlos allí y volverlos a mover.

Desde que publiqué esta pregunta, he aprendido que exes un programa compatible con POSIX. Tiene un enlace simbólico casi universal vim, pero de cualquier manera, lo siguiente es (creo) un punto clave sobre los exsistemas de archivos (tomado de la especificación POSIX):

Esta sección utiliza el término buffer de edición para describir el texto de trabajo actual. Ninguna implementación específica está implícita en este término. Todos los cambios de edición se realizan en el búfer de edición, y ningún cambio afectará a ningún archivo hasta que un comando del editor escriba el archivo.

"... afectará a cualquier archivo ..." Creo que poner algo en el sistema de archivos (en absoluto, incluso un archivo temporal) contaría como "afectar a cualquier archivo". ¿Tal vez?*

El estudio cuidadoso de las especificaciones POSIX paraex indicar algunas "trampas" sobre su uso portátil previsto en comparación con los usos comunes con script de los que se exencuentran en línea (que están llenos de vimcomandos específicos).

1. La implementación +cmdes opcional según POSIX.
2. Permitir múltiples -copciones también es opcional.
3. El comando global :g"come" todo hasta la próxima línea nueva no escapada (y, por lo tanto, lo ejecuta después de cada coincidencia encontrada para la expresión regular en lugar de una vez al final). Entonces -c 'g/regex/d | x'solo elimina una instancia y luego sale del archivo.

Entonces, de acuerdo con lo que he investigado, el método compatible con POSIX para editar in situ un archivo en un sistema de archivos completo para eliminar todas las líneas que coinciden con una expresión regular específica, es:

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

Esto debería funcionar siempre que tenga suficiente memoria para cargar el archivo en un búfer.

_{* Si encuentra algo que indique lo contrario, por favor, menciónelo en los comentarios.}

¡Usa la pipa, Luke!

Leer archivo | filtro | respóndeme

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

en este caso sedno crea un nuevo archivo y solo envía una salida canalizada a la ddque se abre el mismo archivo . Por supuesto, uno puede usar grepen casos particulares

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

luego truncar el resto.

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

Como se señaló en otras respuestas, sed -ifunciona copiando el archivo a un nuevo archivo en el mismo directorio , haciendo cambios en el proceso y luego moviendo el nuevo archivo sobre el original. Por eso no funciona.  ed(el editor de línea original) funciona de manera similar, pero la última vez que lo verifiqué, lo usa /tmppara el archivo scratch. Si /tmpestá en un sistema de archivos diferente del que está lleno, edpuede hacer el trabajo por usted.

Pruebe esto (en su indicador de shell interactivo):

$ ed / ruta / a / archivo / nombre de archivo
PAG
g / myregex / d
w
q

El P(que es una P mayúscula ) no es estrictamente necesario. Se enciende provocando; sin ella, estás trabajando en la oscuridad, y algunas personas encuentran esto desconcertante. El wy qson w rito y q uit.

edEs conocido por el diagnóstico críptico. Si en algún momento muestra algo más que el aviso (que es *) o algo que es claramente una confirmación de operación exitosa ( especialmente si contiene un ?), no escriba el archivo (con w). Solo salga ( q). Si no te deja salir, intenta decirlo de qnuevo.

Si su /tmpdirectorio está en el sistema de archivos que está lleno (o si su sistema de archivos también está lleno), intente encontrar espacio en alguna parte. el caos mencionó el montaje de un tmpfs o un dispositivo de almacenamiento externo (por ejemplo, una unidad flash); pero, si tiene varios sistemas de archivos y no están todos llenos, simplemente puede usar uno de los otros existentes. caos sugiere copiar los archivos al otro sistema de archivos, editarlos allí (con sed) y luego volver a copiarlos. En este punto, esa puede ser la solución más simple. Pero una alternativa sería crear un directorio grabable en un sistema de archivos que tenga algo de espacio libre, establecer la variable de entorno TMPDIRpara que apunte a ese directorio y luego ejecutarlo ed. (Divulgación: no estoy seguro de si esto funcionará, pero no puede doler).

Una vez que empiece a edtrabajar, puede automatizar esto haciendo

nombre de archivo ed << EOF
g / myregex / d
w
q
EOF

en un guion O , como lo sugiere don_crissti.printf '%s\n' 'g/myregex/d' w q | ed -s filename

Puede truncar el archivo con bastante facilidad si puede obtener el recuento de bytes a su desplazamiento y sus líneas se producen desde un punto inicial hasta el final.

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

O bien, si ${TMPDIR:-/tmp}está en algún otro sistema de archivos, tal vez:

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

Porque (la mayoría) los shells ponen sus documentos aquí en un archivo temporal eliminado. Es perfectamente seguro siempre que el <<FILEdescriptor se mantenga de principio a fin y ${TMPDIR:-/tmp}tenga tanto espacio como sea necesario.

Los shells que no usan archivos temporales usan tuberías, por lo que no es seguro usarlos de esta manera. Estos depósitos son típicamente ashderivados como busybox, dash, BSD sh- zsh, bash, ksh, y la cáscara de Bourne, sin embargo, todos los archivos temporales de uso.

aparentemente escribí un pequeño programa de shell en julio pasado para hacer algo como esto

Si /tmpno es viable, entonces, siempre que pueda guardar el archivo en la memoria, algo así como ...

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

... como un caso general, al menos se aseguraría de que el archivo estuviera completamente protegido por el primer sedproceso antes de intentar truncar el archivo de entrada / salida.

Una solución más específica y eficiente podría ser:

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

... porque no molestaría las líneas de almacenamiento en búfer que querías eliminar de todos modos.

Una prueba del caso general:

{   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 respuesta toma prestadas ideas de esta otra respuesta y de esta otra respuesta, pero se basa en ellas, creando una respuesta que es más generalmente aplicable:

num_bytes = $ (sed '/ myregex / d' / path / to / file / filename | wc -c)
sed '/ myregex / d' / path / to / file / filename 1 <> / path / to / file / filename 
dd if = / dev / null of = / path / to / file / filename bs = "$ num_bytes" busque = 1

La primera línea ejecuta el sedcomando con salida escrita en salida estándar (y no en un archivo); específicamente, a una tubería wcpara contar los personajes. La segunda línea también ejecuta el sedcomando con la salida escrita en la salida estándar, que, en este caso, se redirige al archivo de entrada en modo lectura / escritura de sobrescritura (sin truncar), que se trata aquí . Esto es algo peligroso de hacer; es seguro solo cuando el comando de filtro nunca aumenta la cantidad de datos (texto); es decir, por cada n bytes que lee, escribe n o menos bytes. Esto es, por supuesto, cierto para el sed '/myregex/d'comando; por cada línea que lee, escribe exactamente la misma línea, o nada. (Otros ejemplos:s/foo/fu/o s/foo/bar/estaría a salvo, pero s/fu/foo/y s/foo/foobar/no lo estaría).

Por ejemplo:

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

porque estos 32 bytes de datos:

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

se sobrescribió con estos 25 caracteres:

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

dejando los siete bytes night.\nrestantes al final.

Finalmente, el ddcomando busca el final de los nuevos datos depurados (byte 25 en este ejemplo) y elimina el resto del archivo; es decir, trunca el archivo en ese punto.

Si, por alguna razón, el 1<>truco no funciona, puedes hacerlo

sed '/ myregex / d' / ruta / a / archivo / nombre de archivo | dd de = / ruta / a / archivo / nombre de archivo conv = notrunc

Además, tenga en cuenta que, siempre que todo lo que esté haciendo sea eliminar líneas, todo lo que necesita es grep -v myregex(como señaló Barmar ).

sed -i 'd' / ruta / a / archivo / nombre de archivo