mjhjmtu

Problem:
I'm looking for a way to rename or copy a file without overwriting the destination file, if it exists, and then check the success of the move or copy operation. I'm seeking a method that will work with the BSD versions of mv/cp installed on MacOS/Unix, and also the GNU coreutils versions I have on Linux.

Solution attempt:
In all versions of mv/cp, I can prevent overwriting the destination file with the -n flag:

mv -n file1 file2
cp -n file1 file2 

Similar questions suggest testing the success of mv and cp using the exit status, which is 0 if successful and >0 if an error occurred. However, for both versions of mv/cp, the exit code is 0 when the destination file already exists and the -n flag is used.

The only other option I can think of is to also use the -v flag, and look at the output of the command:

mv -nv file1 file2
cp -nv file1 file2

However, the GNU and BSD versions of mv/cp behave differently when the -nv flags are used and file2 already exists: the GNU versions of mv/cp return nothing, whereas the BSD versions return file2 not overwritten.

Our previous method was to check whether the destination file exists first, then do the mv/cp operation. Believe it or not, this caused problems because the destination file would sometimes get created by another process between the time that the check was performed and the mv/cp operation was executed.

Is there a way to accomplish this task that works with both BSD and GNU versions of mv/cp?

Alternatively, is there are way to do this using Python 2? I couldn't find a way to do this using os.rename()

If you have bash - https://stackoverflow.com/questions/13828544/atomic-create-file-if-not-exists-from-bash-script

set -o noclobber
 > file ; &> /dev/null

This command creates a file named file if there's no existent file
named file. If there's a file named file, then do nothing (but return
a non-zero return code).

I.e. create an empty file first using this technique. If that succeeds, you can then overwrite the empty file.

Similarly for python. Use os.open() to create an empty file, making sure to include O_EXCL in the flags. ("For a description of the flag and mode values, see the C run-time documentation." See POSIX standard / Linux man page).

The bash technique is using O_EXCL behind the scenes. There is also RENAME_NOREPLACE, but it is a relatively recent addition in Linux, and I do not think it is present on OS X.

FreeBSD does indeed return failure if cp -n is asked to overwrite a file:

$ rm -f foo.*
$ date > foo.1
$ date > foo.2
$ # this should fail
$ cp -n foo.1 foo.2 || echo fail
fail
$ rm foo.2
$ # this should succeed
$ cp -n foo.1 foo.2 || echo fail
$ exit

You are correct when you state that FreeBSD's mv returns success even when the destination exists:

$ rm -f foo.*
$ date > foo.1
$ date > foo.2
$ # this should fail
$ mv -n foo.1 foo.2 || echo fail
$ exit

One workaround is to && the mv result code with [ ! -f src-file ], as in:

$ rm -f foo.*
$ date > foo.1
$ date > foo.2
$ # this should fail
$ ( mv -n foo.1 foo.2 && [ ! -f foo.1 ] ) || echo fail
fail
$ rm foo.2
$ # this should succeed
$ ( mv -n foo.1 foo.2 && [ ! -f foo.1 ] ) || echo fail
$ exit

Under GNU, neither utility performs the way you would like. The same workaround for mv works for me on Ubuntu, so that leaves GNU cp as as the one remaining problem case.

Just as an aside, I hear your comment about the race condition with testing for the destination file before calling cp, but it strikes me that the same race condition would be present even if cp did the right thing. The window of opportunity might be smaller, but my intuition is that it would still be there. IANAE, however.

Since the workaround for mv works on both platforms, perhaps this workaround will suffice:

$ rm -f foo.*
$ date > foo.1
$ date > foo.2
$ # this should fail
$ ( cp -n foo.1 TEMPFILE && mv -n TEMPFILE foo.2 && [ ! -f TEMPFILE ] ) || echo fail
fail
$ rm -f TEMPFILE
$ rm foo.2
$ # this should succeed
$ ( cp -n foo.1 TEMPFILE && mv -n TEMPFILE foo.2 && [ ! -f TEMPFILE ] ) || echo fail
$ rm -f TEMPFILE
$ exit