Cara mengatasi tautan simbolis dalam skrip shell

Diberikan jalur absolut atau relatif (dalam sistem mirip Unix), saya ingin menentukan jalur lengkap target setelah menyelesaikan setiap symlink perantara. Poin bonus untuk menyelesaikan notasi ~ nama pengguna pada saat yang bersamaan.

Jika targetnya adalah direktori, mungkin chdir () masuk ke direktori dan kemudian memanggil getcwd (), tapi saya benar-benar ingin melakukan ini dari skrip shell daripada menulis C helper. Sayangnya, shell memiliki kecenderungan untuk mencoba menyembunyikan keberadaan symlink dari pengguna (ini bash di OS X):

$ ls -ld foo bar
drwxr-xr-x   2 greg  greg  68 Aug 11 22:36 bar
lrwxr-xr-x   1 greg  greg   3 Aug 11 22:36 foo -> bar
$ cd foo
$ pwd
/Users/greg/tmp/foo
$

Yang saya inginkan adalah fungsi resol () yang ketika dijalankan dari direktori tmp pada contoh di atas, resolus ("foo") == "/ Users / greg / tmp / bar".

Menurut standar, pwd -Pharus mengembalikan jalur dengan symlink diselesaikan.

Fungsi C char *getcwd(char *buf, size_t size)dari unistd.hharus memiliki perilaku yang sama.

getcwd pwd

readlink -f "$path"

^{Catatan editor: Di atas berfungsi dengan GNU readlink dan FreeBSD / PC-BSD / OpenBSD readlink , tetapi tidak pada OS X pada 10.11.
GNU readlink menawarkan opsi tambahan yang terkait, seperti -muntuk menyelesaikan symlink apakah ada target akhir atau tidak.}

Catatan sejak GNU coreutils 8.15 (2012-01-06), ada program realpath yang tersedia yang kurang tumpul dan lebih fleksibel daripada yang di atas. Ini juga kompatibel dengan util FreeBSD dengan nama yang sama. Ini juga mencakup fungsionalitas untuk menghasilkan jalur relatif antara dua file.

realpath $path

[Tambahan admin di bawah ini dari komentar oleh halloleo - danorton ]

Untuk Mac OS X (setidaknya melalui 10.11.x), gunakan readlinktanpa -fopsi:

readlink $path

^{Catatan Editor: Ini tidak akan menyelesaikan symlink secara rekursif dan karenanya tidak akan melaporkan target akhir ; misalnya, diberi symlink ayang menunjuk ke b, yang pada gilirannya menunjuk ke c, ini hanya akan melaporkanb (dan tidak akan memastikan bahwa itu adalah output sebagai jalur absolut ).
Gunakan perlperintah berikut pada OS X untuk mengisi celah readlink -ffungsionalitas yang hilang :
perl -MCwd -le 'print Cwd::abs_path(shift)' "$path"}

"pwd -P" tampaknya berfungsi jika Anda hanya ingin direktori, tetapi jika karena alasan tertentu Anda ingin nama executable aktual saya tidak berpikir itu membantu. Inilah solusi saya:

#!/bin/bash

# get the absolute path of the executable
SELF_PATH=$(cd -P -- "$(dirname -- "$0")" && pwd -P) && SELF_PATH=$SELF_PATH/$(basename -- "$0")

# resolve symlinks
while [[ -h $SELF_PATH ]]; do
    # 1) cd to directory of the symlink
    # 2) cd to the directory of where the symlink points
    # 3) get the pwd
    # 4) append the basename
    DIR=$(dirname -- "$SELF_PATH")
    SYM=$(readlink "$SELF_PATH")
    SELF_PATH=$(cd "$DIR" && cd "$(dirname -- "$SYM")" && pwd)/$(basename -- "$SYM")
done

Salah satu favorit saya adalah realpath foo

realpath - mengembalikan pathname absolut yang dikanonikalisasi

realpath memperluas semua tautan simbolis dan menyelesaikan referensi ke karakter '/./', '/../' dan ekstra '/' dalam string null yang diakhiri dengan nama path dan
       menyimpan pathname absolut yang dikanonikalisasi dalam buffer ukuran PATH_MAX yang dinamai oleh resolved_path. Jalur yang dihasilkan tidak akan memiliki tautan simbolis, '/./' atau
       Komponen '/../'.

readlink -e [filepath]

tampaknya persis seperti yang Anda minta - ia menerima jalur arbirary, menyelesaikan semua symlink, dan mengembalikan jalur "nyata" - dan itu "standar * nix" yang kemungkinan semua sistem sudah memiliki

Cara lain:

# Gets the real path of a link, following all links
myreadlink() { [ ! -h "$1" ] && echo "$1" || (local link="$(expr "$(command ls -ld -- "$1")" : '.*-> \(.*\)$')"; cd $(dirname $1); myreadlink "$link" | sed "s|^\([^/].*\)\$|$(dirname $1)/\1|"); }

# Returns the absolute path to a command, maybe in $PATH (which) or not. If not found, returns the same
whereis() { echo $1 | sed "s|^\([^/].*/.*\)|$(pwd)/\1|;s|^\([^/]*\)$|$(which -- $1)|;s|^$|$1|"; } 

# Returns the realpath of a called command.
whereis_realpath() { local SCRIPT_PATH=$(whereis $1); myreadlink ${SCRIPT_PATH} | sed "s|^\([^/].*\)\$|$(dirname ${SCRIPT_PATH})/\1|"; } 

Menyatukan beberapa solusi yang diberikan, mengetahui bahwa readlink tersedia di sebagian besar sistem, tetapi membutuhkan argumen yang berbeda, ini berfungsi baik untuk saya di OSX dan Debian. Saya tidak yakin tentang sistem BSD. Mungkin kondisinya perlu [[ $OSTYPE != darwin* ]]dikecualikan -fdari OSX saja.

#!/bin/bash
MY_DIR=$( cd $(dirname $(readlink `[[ $OSTYPE == linux* ]] && echo "-f"` $0)) ; pwd -P)
echo "$MY_DIR"

Berikut ini cara mendapatkan jalur sebenarnya ke file di MacOS / Unix menggunakan skrip inline Perl:

FILE=$(perl -e "use Cwd qw(abs_path); print abs_path('$0')")

Demikian pula, untuk mendapatkan direktori file yang disinkronkan:

DIR=$(perl -e "use Cwd qw(abs_path); use File::Basename; print dirname(abs_path('$0'))")

Apakah jalur Anda direktori, atau mungkin itu file? Jika itu direktori, sederhana saja:

(cd "$DIR"; pwd -P)

Namun, jika itu mungkin file, maka ini tidak akan berfungsi:

DIR=$(cd $(dirname "$FILE"); pwd -P); echo "${DIR}/$(readlink "$FILE")"

karena symlink mungkin menyelesaikan ke jalur relatif atau penuh.

Pada skrip saya perlu menemukan path yang sebenarnya, sehingga saya dapat merujuk konfigurasi atau skrip lain yang diinstal bersama dengannya, saya menggunakan ini:

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done

Anda dapat mengatur SOURCEjalur file apa pun. Pada dasarnya, selama path adalah symlink, ia menyelesaikan symlink tersebut. Triknya ada di baris terakhir loop. Jika symlink yang diselesaikan mutlak, ia akan menggunakannya sebagai SOURCE. Namun, jika itu relatif, itu akan menambah DIRuntuk itu, yang diselesaikan menjadi lokasi nyata dengan trik sederhana yang saya jelaskan pertama kali.

function realpath {
    local r=$1; local t=$(readlink $r)
    while [ $t ]; do
        r=$(cd $(dirname $r) && cd $(dirname $t) && pwd -P)/$(basename $t)
        t=$(readlink $r)
    done
    echo $r
}

#example usage
SCRIPT_PARENT_DIR=$(dirname $(realpath "$0"))/..

^{Catatan: Saya percaya ini menjadi solusi yang solid, portabel, siap pakai, yang selalu panjang untuk alasan itu.}

Di bawah ini adalah script / fungsi yang sepenuhnya kompatibel dengan POSIX yang karena itu lintas platform (berfungsi pada macOS juga, yang readlinkmasih belum mendukung -fpada 10.12 (Sierra)) - ini hanya menggunakan fitur bahasa shell POSIX dan hanya panggilan utilitas yang sesuai dengan POSIX .

Ini adalah implementasi portabel dari GNUreadlink -e (versi yang lebih ketat readlink -f).

Anda dapat menjalankan skrip dengansh atau sumber yang fungsi dalam bash, kshdanzsh :

Misalnya, di dalam skrip Anda dapat menggunakannya sebagai berikut untuk mendapatkan direktori asli skrip yang menjalankan asalnya, dengan symlink yang diselesaikan:

trueScriptDir=$(dirname -- "$(rreadlink "$0")")

rreadlink definisi skrip / fungsi:

^{Kode diadaptasi dengan rasa terima kasih dari jawaban ini .
Saya juga membuat bashversi utilitas yang berdiri sendiri di sini , yang dapat Anda instal
npm install rreadlink -g, jika Node.js telah diinstal.}

#!/bin/sh

# SYNOPSIS
#   rreadlink <fileOrDirPath>
# DESCRIPTION
#   Resolves <fileOrDirPath> to its ultimate target, if it is a symlink, and
#   prints its canonical path. If it is not a symlink, its own canonical path
#   is printed.
#   A broken symlink causes an error that reports the non-existent target.
# LIMITATIONS
#   - Won't work with filenames with embedded newlines or filenames containing 
#     the string ' -> '.
# COMPATIBILITY
#   This is a fully POSIX-compliant implementation of what GNU readlink's
#    -e option does.
# EXAMPLE
#   In a shell script, use the following to get that script's true directory of origin:
#     trueScriptDir=$(dirname -- "$(rreadlink "$0")")
rreadlink() ( # Execute the function in a *subshell* to localize variables and the effect of `cd`.

  target=$1 fname= targetDir= CDPATH=

  # Try to make the execution environment as predictable as possible:
  # All commands below are invoked via `command`, so we must make sure that
  # `command` itself is not redefined as an alias or shell function.
  # (Note that command is too inconsistent across shells, so we don't use it.)
  # `command` is a *builtin* in bash, dash, ksh, zsh, and some platforms do not 
  # even have an external utility version of it (e.g, Ubuntu).
  # `command` bypasses aliases and shell functions and also finds builtins 
  # in bash, dash, and ksh. In zsh, option POSIX_BUILTINS must be turned on for
  # that to happen.
  { \unalias command; \unset -f command; } >/dev/null 2>&1
  [ -n "$ZSH_VERSION" ] && options[POSIX_BUILTINS]=on # make zsh find *builtins* with `command` too.

  while :; do # Resolve potential symlinks until the ultimate target is found.
      [ -L "$target" ] || [ -e "$target" ] || { command printf '%s\n' "ERROR: '$target' does not exist." >&2; return 1; }
      command cd "$(command dirname -- "$target")" # Change to target dir; necessary for correct resolution of target path.
      fname=$(command basename -- "$target") # Extract filename.
      [ "$fname" = '/' ] && fname='' # !! curiously, `basename /` returns '/'
      if [ -L "$fname" ]; then
        # Extract [next] target path, which may be defined
        # *relative* to the symlink's own directory.
        # Note: We parse `ls -l` output to find the symlink target
        #       which is the only POSIX-compliant, albeit somewhat fragile, way.
        target=$(command ls -l "$fname")
        target=${target#* -> }
        continue # Resolve [next] symlink target.
      fi
      break # Ultimate target reached.
  done
  targetDir=$(command pwd -P) # Get canonical dir. path
  # Output the ultimate target's canonical path.
  # Note that we manually resolve paths ending in /. and /.. to make sure we have a normalized path.
  if [ "$fname" = '.' ]; then
    command printf '%s\n' "${targetDir%/}"
  elif  [ "$fname" = '..' ]; then
    # Caveat: something like /var/.. will resolve to /private (assuming /var@ -> /private/var), i.e. the '..' is applied
    # AFTER canonicalization.
    command printf '%s\n' "$(command dirname -- "${targetDir}")"
  else
    command printf '%s\n' "${targetDir%/}/$fname"
  fi
)

rreadlink "$@"

Garis singgung tentang keamanan:

jarno , mengacu pada fungsi yang memastikan bahwa builtin commandtidak dibayangi oleh fungsi alias atau shell dengan nama yang sama, bertanya dalam komentar:

Bagaimana jika unaliasatau unsetdan [ditetapkan sebagai alias atau fungsi shell?

Motivasi di balik rreadlinkmemastikan bahwa commandmemiliki makna aslinya adalah menggunakannya untuk mem-bypass (jinak) alias kenyamanan dan fungsi yang sering digunakan untuk membayangi perintah standar dalam shell interaktif, seperti mendefinisikan ulangls untuk menyertakan opsi favorit.

Saya pikir aman untuk mengatakan bahwa kecuali Anda sedang berurusan dengan, lingkungan berbahaya tidak terpercaya, mengkhawatirkan unaliasatau unset- atau, dalam hal ini, while, do, ... - yang didefinisikan ulang tidak perhatian.

Ada sesuatu yang fungsi harus andalkan untuk memiliki makna dan perilaku aslinya - tidak ada jalan lain untuk itu.
Kerang seperti POSIX memungkinkan pendefinisian ulang builtin dan bahkan kata kunci bahasa secara inheren risiko keamanan (dan menulis kode paranoid sulit pada umumnya).

Untuk mengatasi masalah Anda secara khusus:

Fungsi ini bergantung pada unaliasdan unsetmemiliki makna aslinya. Setelah mereka didefinisikan ulang sebagai fungsi shell dengan cara yang mengubah perilaku mereka akan menjadi masalah; redefinisi sebagai alias tidak selalu menjadi perhatian, karena mengutip (bagian dari) nama perintah (misalnya, \unalias) mem-bypass alias.

Namun, mengutip adalah bukan pilihan bagi shell kata kunci ( while, for, if, do, ...) dan sementara kata kunci shell melakukan take didahulukan atas shell fungsi , di bashdan zshalias memiliki hak tertinggi, sehingga untuk menjaga terhadap redefinitions shell-kata kunci Anda harus menjalankan unaliasdengan nama mereka (meskipun dalam shell non-interaktif bash (seperti skrip) alias tidak diperluas secara default - hanya jika shopt -s expand_aliasessecara eksplisit disebut pertama).

Untuk memastikan bahwa unalias- sebagai builtin - memiliki makna aslinya, Anda harus menggunakannya \unsetterlebih dahulu, yang mengharuskan yang unsetmemiliki makna aslinya:

unsetadalah shell builtin , jadi untuk memastikan bahwa itu dipanggil seperti itu, Anda harus memastikan bahwa itu sendiri tidak didefinisikan ulang sebagai suatu fungsi . Meskipun Anda bisa mem-bypass formulir alias dengan mengutip, Anda tidak bisa mem-bypass formulir fungsi shell - catch 22.

Jadi, kecuali Anda dapat mengandalkan unsetuntuk memiliki makna aslinya, dari apa yang dapat saya katakan, tidak ada cara yang pasti untuk mempertahankan diri dari semua definisi-ulang berbahaya.

Script shell umum sering harus menemukan direktori "home" mereka walaupun mereka dipanggil sebagai symlink. Jadi skrip harus menemukan posisi "asli" mereka hanya dari $ 0.

cat `mvn`

pada sistem saya mencetak skrip yang berisi berikut ini, yang seharusnya menjadi petunjuk yang baik pada apa yang Anda butuhkan.

if [ -z "$M2_HOME" ] ; then
  ## resolve links - $0 may be a link to maven's home
  PRG="$0"

  # need this for relative symlinks
  while [ -h "$PRG" ] ; do
    ls=`ls -ld "$PRG"`
    link=`expr "$ls" : '.*-> \(.*\)$'`
    if expr "$link" : '/.*' > /dev/null; then
      PRG="$link"
    else
      PRG="`dirname "$PRG"`/$link"
    fi
  done

  saveddir=`pwd`

  M2_HOME=`dirname "$PRG"`/..

  # make it fully qualified
  M2_HOME=`cd "$M2_HOME" && pwd`

Coba ini:

cd $(dirname $([ -L $0 ] && readlink -f $0 || echo $0))

Karena saya telah mengalami ini berkali-kali selama bertahun-tahun, dan kali ini saya membutuhkan versi portabel bash murni yang dapat saya gunakan di OSX dan linux, saya melanjutkan dan menulis satu:

Versi hidup tinggal di sini:

https://github.com/keen99/shell-functions/tree/master/resolve_path

tetapi demi SO, inilah versi saat ini (saya merasa sudah teruji dengan baik..tapi saya terbuka untuk umpan balik!)

Mungkin tidak sulit untuk membuatnya bekerja untuk shell bourne biasa (sh), tapi saya tidak mencoba ... Saya suka $ FUNCNAME terlalu banyak. :)

#!/bin/bash

resolve_path() {
    #I'm bash only, please!
    # usage:  resolve_path <a file or directory> 
    # follows symlinks and relative paths, returns a full real path
    #
    local owd="$PWD"
    #echo "$FUNCNAME for $1" >&2
    local opath="$1"
    local npath=""
    local obase=$(basename "$opath")
    local odir=$(dirname "$opath")
    if [[ -L "$opath" ]]
    then
    #it's a link.
    #file or directory, we want to cd into it's dir
        cd $odir
    #then extract where the link points.
        npath=$(readlink "$obase")
        #have to -L BEFORE we -f, because -f includes -L :(
        if [[ -L $npath ]]
         then
        #the link points to another symlink, so go follow that.
            resolve_path "$npath"
            #and finish out early, we're done.
            return $?
            #done
        elif [[ -f $npath ]]
        #the link points to a file.
         then
            #get the dir for the new file
            nbase=$(basename $npath)
            npath=$(dirname $npath)
            cd "$npath"
            ndir=$(pwd -P)
            retval=0
            #done
        elif [[ -d $npath ]]
         then
        #the link points to a directory.
            cd "$npath"
            ndir=$(pwd -P)
            retval=0
            #done
        else
            echo "$FUNCNAME: ERROR: unknown condition inside link!!" >&2
            echo "opath [[ $opath ]]" >&2
            echo "npath [[ $npath ]]" >&2
            return 1
        fi
    else
        if ! [[ -e "$opath" ]]
         then
            echo "$FUNCNAME: $opath: No such file or directory" >&2
            return 1
            #and break early
        elif [[ -d "$opath" ]]
         then 
            cd "$opath"
            ndir=$(pwd -P)
            retval=0
            #done
        elif [[ -f "$opath" ]]
         then
            cd $odir
            ndir=$(pwd -P)
            nbase=$(basename "$opath")
            retval=0
            #done
        else
            echo "$FUNCNAME: ERROR: unknown condition outside link!!" >&2
            echo "opath [[ $opath ]]" >&2
            return 1
        fi
    fi
    #now assemble our output
    echo -n "$ndir"
    if [[ "x${nbase:=}" != "x" ]]
     then
        echo "/$nbase"
    else 
        echo
    fi
    #now return to where we were
    cd "$owd"
    return $retval
}

inilah contoh klasik, terima kasih untuk menyeduh:

%% ls -l `which mvn`
lrwxr-xr-x  1 draistrick  502  29 Dec 17 10:50 /usr/local/bin/mvn@ -> ../Cellar/maven/3.2.3/bin/mvn

gunakan fungsi ini dan itu akan mengembalikan jalur -real-:

%% cat test.sh
#!/bin/bash
. resolve_path.inc
echo
echo "relative symlinked path:"
which mvn
echo
echo "and the real path:"
resolve_path `which mvn`


%% test.sh

relative symlinked path:
/usr/local/bin/mvn

and the real path:
/usr/local/Cellar/maven/3.2.3/libexec/bin/mvn 

Untuk mengatasi ketidakcocokan Mac, saya datang dengan

echo `php -r "echo realpath('foo');"`

Tidak hebat selain cross OS

Ini adalah penyelesai symlink di Bash yang berfungsi apakah tautannya adalah direktori atau bukan-direktori:

function readlinks {(
  set -o errexit -o nounset
  declare n=0 limit=1024 link="$1"

  # If it's a directory, just skip all this.
  if cd "$link" 2>/dev/null
  then
    pwd -P
    return 0
  fi

  # Resolve until we are out of links (or recurse too deep).
  while [[ -L $link ]] && [[ $n -lt $limit ]]
  do
    cd "$(dirname -- "$link")"
    n=$((n + 1))
    link="$(readlink -- "${link##*/}")"
  done
  cd "$(dirname -- "$link")"

  if [[ $n -ge $limit ]]
  then
    echo "Recursion limit ($limit) exceeded." >&2
    return 2
  fi

  printf '%s/%s\n' "$(pwd -P)" "${link##*/}"
)}

Perhatikan bahwa semua cddan sethal-hal terjadi di subkulit.

Di sini saya menyajikan apa yang saya yakini sebagai solusi lintas platform (Linux dan setidaknya MacOS) untuk jawaban yang bekerja dengan baik untuk saya saat ini.

crosspath()
{
    local ref="$1"
    if [ -x "$(which realpath)" ]; then
        path="$(realpath "$ref")"
    else
        path="$(readlink -f "$ref" 2> /dev/null)"
        if [ $? -gt 0 ]; then
            if [ -x "$(which readlink)" ]; then
                if [ ! -z "$(readlink "$ref")" ]; then
                    ref="$(readlink "$ref")"
                fi
            else
                echo "realpath and readlink not available. The following may not be the final path." 1>&2
            fi
            if [ -d "$ref" ]; then
                path="$(cd "$ref"; pwd -P)"
            else
                path="$(cd $(dirname "$ref"); pwd -P)/$(basename "$ref")"
            fi
        fi
    fi
    echo "$path"
}

Berikut ini adalah solusi macOS (hanya?). Mungkin lebih cocok untuk pertanyaan awal.

mac_realpath()
{
    local ref="$1"
    if [[ ! -z "$(readlink "$ref")" ]]; then
        ref="$(readlink "$1")"
    fi
    if [[ -d "$ref" ]]; then
        echo "$(cd "$ref"; pwd -P)"
    else
        echo "$(cd $(dirname "$ref"); pwd -P)/$(basename "$ref")"
    fi
}

Jawaban saya di sini Bash: bagaimana cara mendapatkan jalur symlink yang sebenarnya?

tetapi singkatnya sangat berguna dalam skrip:

script_home=$( dirname $(realpath "$0") )
echo Original script home: $script_home

Ini adalah bagian dari GNU coreutils, cocok untuk digunakan dalam sistem Linux.

Untuk menguji semuanya, kami menaruh symlink ke / home / test2 /, mengubah beberapa hal tambahan dan menjalankan / memanggilnya dari direktori root:

/$ /home/test2/symlink
/home/test
Original script home: /home/test

Dimana

Original script is: /home/test/realscript.sh
Called script is: /home/test2/symlink

Jika pwd tidak dapat digunakan (mis. Memanggil skrip dari lokasi lain), gunakan realpath (dengan atau tanpa dirname):

$(dirname $(realpath $PATH_TO_BE_RESOLVED))

Berfungsi baik saat memanggil melalui (banyak) symlink (s) atau ketika langsung memanggil skrip - dari lokasi mana pun.