What is the most direct way to convert a symlink into a regular file (i.e. a copy of the symlink target)?
Suppose filename is a symlink to target. The obvious procedure to turn it into a copy is:
cp filename filename-backup
rm filename
mv filename-backup filename
Is there a more direct way (i.e. a single command)?
There is no single command to convert a symlink to a regular file. The most direct way is to use readlink to find the file a symlink points to, and then copy that file over the symlink:
cp --remove-destination `readlink bar.pdf` bar.pdf
Of course, if bar.pdf is, in fact, a regular file to begin with, then this will clobber the file. Some sanity checking would therefore be advisable.
for f in $(find -type l);do cp --remove-destination $(readlink $f) $f;done;
find -type lreadlink $fcp --remove-destination $(readlink $f) $f
Just a rehash of other's answers, but adding the "sanity check" to ensure the link passed in is actually a symbolic link:
removelink() {
[ -L "$1" ] && cp --remove-destination "$(readlink "$1")" "$1"
}
This is saying that if the file is a symbolic link, then run the copy command.
For text files the sed command can do this in one line if you pass it the in-place switch (-i). This is because sed does a single pass over a file, cats the output into a temporary file which it subsequently renames to match the original.
Just do an inline sed with no transforms:
sed -i ';' /path/to/symbolic/link
On OSX
rsync `readlink bar.pdf` bar.pdf
This solution works with symlink files and symlink folders/subfolders.
One line, no script needed. This would be ideal to export or transfer symlinks elsewhere.
Put everything inside a folder.
rsync --archive --copy-links --recursive folderContainingSymlinkFilesAndSymlinkFoldersAndSubfolders myNewFolder
cp can remove the destination file:
cp --remove-destination target filename
Many have already stated the following solution:
cp --remove-destination `readlink file` file
However, this will not work on symbolically linked directories.
Adding a recursive and force will not work either:
cp -rf --remove-destination `readlink file` file
cp: cannot copy a directory, ‘path/file, into itself, ‘file’
Therefore, it is probably safer to delete the symlink entirely first:
resolve-symbolic-link() {
if [ -L $1 ]; then
temp="$(readlink "$1")";
rm -rf "$1";
cp -rf "$temp" "$1";
fi
}
Not exactly a one-liner like you had hoped, but put this it into your shell environment, and it can be.
Another approach if you find yourself doing this often is adapting kbrock's answer into a shell script and putting it into /usr/bin/. Something along the lines of:
if [ $# -ne 1 ]
then
echo "Usage: $0 filename"
exit 1
fi
[ -L "$1" ] && cp --remove-destination "$(readlink "$1")" "$1"
chmod +x it, and then just run it as a normal command.
Change all file.txt from link into file.
for f in *.txt; do echo $(readlink $f) $f | awk '{print "rsync -L "$1" "$2}'; done | bash
I tried to synthesize everything above into a total solution. I do a "deep de-link", so there's an extra call to find even when it's not needed. Someone may want to add a --deep option to prevent the double-find, which in the case of large dir trees, may be very expensive. (Sorry for all the 1-liners)
#!/bin/bash
[[ -z $1 ]] && target="." || target=$1
last_wc=0
links=$(/bin/find $target -type l)
rc=$? && [[ $rc -ne 0 ]] && exit $rc
while true; do
wc=$(echo $links | /bin/wc -w)
[[ $wc -eq $last_wc ]] && break
for f in $links; do
link_target=$(/bin/readlink --canonicalize-existing --no-newline --verbose "$f")
[[ $? -ne 0 ]] && continue
if [[ -d "$link_target" ]]; then
cmd="/bin/rm -f '$f' && /bin/cp -r '$link_target' '$f'"
else
cmd="/bin/rm -f '$f' && /bin/cp '$link_target' '$f'"
fi
eval $cmd
[[ $? -ne 0 ]] && echo "WARNING: Problem running '$cmd'" >&2
done
last_wc=$wc
links=$(/bin/find $target -type l)
done
Rsync can nativly deference the symlink for you using -L flag.
[user@workstation ~]$ rsync -h | grep -- -L
-L, --copy-links transform symlink into referent file/dir
It would be as simple as: rsync -L <symlink> <destination>
This worked perfectly for me (edited to work with spaces):
find . -type l | while read f; do /bin/cp -rf --remove-destination -f $(find . -name $(readlink "${f}")) "${f}";done;
Allows you to recursively convert all symlinks under the current working folder to its regular file. Also doesn't ask you to overwrite. the "/bin/cp" exists so that you can bypass a possible cp -i alias on your OS which prevents the "-rf" from working.
in case of "relative" symlinks you could add a awk statement to @jared answer:
for f in $(find . -type l); do /bin/cp -rf --remove-destination -f $(find . \! -type l -name $(readlink $f | awk -F"../" '{print $NF}')) $f;done;
If you have symlinks pointing to directories you need to use a more radical approach because cp --remove-destination does not work together with symlinks directories correctly
for f in `find . -type l`; do (cd `dirname $f`; target=`basename $f`; source=`readlink $target` ; rm -rf $target && cp -r $source $target); done
For sure this could be written with less overhead. but it is quite good to read in my opinion.
The most direct way, if both the source and target of the link are on the same partition, is to convert soft-links to a hard-links (I assume the current links are soft). And it's done.
This effectively accomplishes the 'copying'. If you check the disk usage size (du) of a directory of all soft symlinks, then perform the hard-link conversion (below), and check again, the 'after' du size reflects the actual original file sizes. Then you can rm the source of the link at any time without effecting the target of the hardlink.
find . -type l -exec bash -c 'ln -f "$(readlink -m "$0")" "$0"' {} \;
There's no single command. But if you don't want a copy and all you want is another reference, you can replace the symlink with a link (aka "hard link"). This only works if they're on the same partition, BTW.
rm filename
ln target filename
