¿Cómo se abre (lectura-escritura) o se crea un archivo con truncamiento permitido?

Question

Quiero:

• abrir un archivo en modo lectura-escritura si existe;
• créelo si no existe;
• ser capaz de truncar en cualquier momento y en cualquier lugar.

EDITAR: con truncado me refiero a escribir hasta una posición y desechar el resto del archivo, si está presente

Todo esto atómicamente (con un solo open() llamada o la simulación de una sola open() llamada)

sin sola modalidad abierta parece aplicarse:

• r: es evidente que no funciona;
• r +: falla si el archivo no existe;
• w: recrear el archivo si existe;
• w +: vuelve a crear el archivo si existe;
• a: no se puede leer;
• a +: no se puede truncar.

Algunas combinaciones que probé (rw, rw +, r + w, etc.) parece que no funcionan. ¿Es posible?

Algunos doc de Rubí (se aplica a pitón también):

r 
Read-only mode. The file pointer is placed at the beginning of the file. 
This is the default mode. 

r+ 
Read-write mode. The file pointer will be at the beginning of the file. 

w 
Write-only mode. Overwrites the file if the file exists. If the file 
does not exist, creates a new file for writing. 

w+ 
Read-write mode. Overwrites the existing file if the file exists. If the 
file does not exist, creates a new file for reading and writing. 

a 
Write-only mode. The file pointer is at the end of the file if the file 
exists. That is, the file is in the append mode. If the file does not exist, 
it creates a new file for writing. 

a+ 
Read and write mode. The file pointer is at the end of the file if the file 
exists. The file opens in the append mode. If the file does not exist, it 
creates a new file for reading and writing. 

Answer 1

Según OpenGroup:

O_TRUNC

Si el archivo existe y es un archivo regular, y el archivo es éxito abrió O_RDWR o O_WRONLY, su longitud se trunca a 0 y el modo y el propietario no ha cambiado. No tendrá ningún efecto en los archivos especiales FIFO ni en los archivos del dispositivo terminal. Su efecto en otros tipos de archivos es según la implementación. El resultado de usar O_TRUNC con O_RDONLY es undefined.

Entonces, O_TRUNC probablemente se pasa al abrir un archivo con "w" o "w +". Esto le da a "truncamiento" un significado diferente, no lo que yo quiero.

Con python, la solución parece abrir el archivo en la E/S de bajo nivel con la función os.open().

La siguiente función de Python:

def touchopen(filename, *args, **kwargs): 
    # Open the file in R/W and create if it doesn't exist. *Don't* pass O_TRUNC 
    fd = os.open(filename, os.O_RDWR | os.O_CREAT) 

    # Encapsulate the low-level file descriptor in a python file object 
    return os.fdopen(fd, *args, **kwargs) 

tiene el comportamiento que quería. Se puede utilizar de esta manera (que es de hecho mi caso de uso):

# Open an existing file or create if it doesn't exist 
with touchopen("./tool.run", "r+") as doing_fd: 

    # Acquire a non-blocking exclusive lock 
    fcntl.lockf(doing_fd, fcntl.LOCK_EX) 

    # Read a previous value if present 
    previous_value = doing_fd.read() 
    print previous_value 

    # Write the new value and truncate 
    doing_fd.seek(0) 
    doing_fd.write("new value") 
    doing_fd.truncate() 

Answer 2

no sé de ninguna manera elegante de hacer exactamente esto en Ruby. Mi solución probablemente sería crear un archivo temporal, escribir contenido en él y luego cambiarle el nombre al nombre que realmente quería. Esto sobrescribiría el archivo anterior si existe, o crearía el archivo si no existiera. Algo como esto:

orig_filename = './whatever_file.log' 
temp_filename = './.tempfile' 
temp_file = File.new(temp_filename, 'w') 

// Write contents to file 

temp_file.close 
File.rename(temp_filename, orig_filename) 

El cambio de nombre elevará SystemCallError si falla por cualquier razón.

Answer 3

Bueno, solo existen estos modos, y todos ellos tienen los "defectos" que enumeró.

Su única opción es envolver open(). ¿Por qué no algo como esto? (Python)

def touchopen(filename, *args, **kwargs): 
    open(filename, "a").close() # "touch" file 
    return open(filename, *args, **kwargs) 

se comporta como abierta, incluso se podría volver a enlazar a abrir() si realmente desea.

todas las características de abiertos se conservan, incluso se puede hacer:

with touchopen("testfile", "r+") as testfile: 
    do_stuff() 

Se podría, por supuesto, crear una ContextManager que se abre el archivo en un modo +, lo lee en la memoria, e intercepta escribe lo que maneja el truncamiento creando mágicamente un archivo temporal en el modo w, y cambia el nombre de ese archivo temporal a tu archivo original cuando lo cierras, pero supongo que eso supondría un exceso.

Answer 4

se puede leer, escribir y truncar con "A +" (Rubí):

File.open("test.txt", "a+") do |f| 
    f.print "abc\ndefgh" 
    f.rewind 
    p f.read 
    f.truncate(5) 
end 
puts File.size("test.txt") #=> 5