I want to:
EDIT: with truncate I mean write until a position and discard the remaining part of the file, if present
All this atomically (with a single
open() call or simulating a single
No single open modality seems to apply:
Some combinations I tried (rw, rw+, r+w, etc.) seems to not work either. Is it possible?
Some doc from Ruby (applies to python too):
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.
According to OpenGroup:
If the file exists and is a regular file, and the file is successfully opened O_RDWR or O_WRONLY, its length is truncated to 0 and the mode and owner are unchanged. It will have no effect on FIFO special files or terminal device files. Its effect on other file types is implementation-dependent. The result of using O_TRUNC with O_RDONLY is undefined.
So, O_TRUNC is probably passed when opening a file with "w" or "w+". This gives "truncation" a different meaning, not what I want.
With python the solution seems to open file at low-level I/O with
The following python function:
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)
has the behavior I wanted. You can use it like this (it's in fact my use case):
# 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()
Well, there are only these modes, and all of them have the "defects" you listed.
Your only option is to wrap
Why not something like this? (Python)
def touchopen(filename, *args, **kwargs): open(filename, "a").close() # "touch" file return open(filename, *args, **kwargs)
it behaves just like open, you could even rebind it to open() if you really wish.
all of open's features are preserved, you can even do:
with touchopen("testfile", "r+") as testfile: do_stuff()
You could of course create a contextmanager which opens the file in a+ mode, reads it into memory, and intercepts writes so you handle truncation by magically creating a temporary file in w mode, and renames that tempfile to your original file when you close it, but that would be overkill I guess.