Bagaimana saya bisa mendapatkan perilaku readlink -f GNU di Mac?

Di Linux, readlinkutilitas menerima opsi -fyang mengikuti tautan tambahan. Ini sepertinya tidak berfungsi pada Mac dan mungkin sistem berbasis BSD. Apa yang akan menjadi setara?

Berikut ini beberapa informasi debug:

$ which readlink; readlink -f
/usr/bin/readlink
readlink: illegal option -f
usage: readlink [-n] [file ...]

readlink -f melakukan dua hal:

1. Iterates di sepanjang urutan symlinks sampai menemukan file yang sebenarnya.
2. Ini mengembalikan nama file yang dikanonikalisasi - yaitu pathname absolutnya.

Jika Anda mau, Anda bisa membuat skrip shell yang menggunakan perilaku readlink vanilla untuk mencapai hal yang sama. Ini sebuah contoh. Jelas Anda bisa memasukkan ini ke dalam skrip Anda sendiri tempat Anda ingin meneleponreadlink -f

#!/bin/sh

TARGET_FILE=$1

cd `dirname $TARGET_FILE`
TARGET_FILE=`basename $TARGET_FILE`

# Iterate down a (possible) chain of symlinks
while [ -L "$TARGET_FILE" ]
do
    TARGET_FILE=`readlink $TARGET_FILE`
    cd `dirname $TARGET_FILE`
    TARGET_FILE=`basename $TARGET_FILE`
done

# Compute the canonicalized name by finding the physical path 
# for the directory we're in and appending the target file.
PHYS_DIR=`pwd -P`
RESULT=$PHYS_DIR/$TARGET_FILE
echo $RESULT

Perhatikan bahwa ini tidak termasuk penanganan kesalahan. Yang paling penting, ini tidak mendeteksi siklus symlink. Cara sederhana untuk melakukan ini adalah dengan menghitung berapa kali Anda berputar-putar dan gagal jika Anda menekan angka yang sangat besar, seperti 1.000.

Diedit untuk digunakan pwd -Psebagai gantinya $PWD.

Perhatikan bahwa skrip ini mengharapkan dipanggil seperti ./script_name filename, tidak -f, ubah $1menjadi $2jika Anda ingin dapat menggunakan dengan -f filenametautan baca GNU seperti.

MacPorts dan Homebrew menyediakan coreutils paket berisi greadlink(GNU readlink). Kredit ke posting Michael Kallweitt di mackb.com.

brew install coreutils

greadlink -f file.txt

Anda mungkin tertarik realpath(3), atau Python os.path.realpath. Keduanya tidak persis sama; panggilan pustaka C mengharuskan komponen jalur perantara ada, sedangkan versi Python tidak.

$ pwd
/tmp/foo
$ ls -l
total 16
-rw-r--r--  1 miles    wheel  0 Jul 11 21:08 a
lrwxr-xr-x  1 miles    wheel  1 Jul 11 20:49 b -> a
lrwxr-xr-x  1 miles    wheel  1 Jul 11 20:49 c -> b
$ python -c 'import os,sys;print(os.path.realpath(sys.argv[1]))' c
/private/tmp/foo/a

Saya tahu Anda mengatakan Anda lebih suka sesuatu yang lebih ringan daripada bahasa scripting lain, tetapi kalau-kalau kompilasi biner tidak dapat disangkal, Anda dapat menggunakan Python dan ctypes (tersedia di Mac OS X 10.5) untuk membungkus panggilan perpustakaan:

#!/usr/bin/python

import ctypes, sys

libc = ctypes.CDLL('libc.dylib')
libc.realpath.restype = ctypes.c_char_p
libc.__error.restype = ctypes.POINTER(ctypes.c_int)
libc.strerror.restype = ctypes.c_char_p

def realpath(path):
    buffer = ctypes.create_string_buffer(1024) # PATH_MAX
    if libc.realpath(path, buffer):
        return buffer.value
    else:
        errno = libc.__error().contents.value
        raise OSError(errno, "%s: %s" % (libc.strerror(errno), buffer.value))

if __name__ == '__main__':
    print realpath(sys.argv[1])

Ironisnya, versi C dari skrip ini seharusnya lebih pendek. :)

Saya benci untuk melanjutkan dengan implementasi lain, tetapi saya membutuhkan a) implementasi portabel, shell murni , dan b) cakupan unit-test , karena jumlah kasus tepi untuk sesuatu seperti ini adalah non-sepele .

Lihat proyek saya di Github untuk tes dan kode lengkap. Berikut ini adalah sinopsis implementasi:

Seperti yang ditunjukkan Keith Smith dengan cerdas, readlink -flakukan dua hal: 1) menyelesaikan symlink secara rekursif, dan 2) mengkanoniskan hasilnya, dengan demikian:

realpath() {
    canonicalize_path "$(resolve_symlinks "$1")"
}

Pertama, implementasi resollink symlink:

resolve_symlinks() {
    local dir_context path
    path=$(readlink -- "$1")
    if [ $? -eq 0 ]; then
        dir_context=$(dirname -- "$1")
        resolve_symlinks "$(_prepend_path_if_relative "$dir_context" "$path")"
    else
        printf '%s\n' "$1"
    fi
}

_prepend_path_if_relative() {
    case "$2" in
        /* ) printf '%s\n' "$2" ;;
         * ) printf '%s\n' "$1/$2" ;;
    esac 
}

Perhatikan bahwa ini adalah versi implementasi penuh yang sedikit disederhanakan . Implementasi penuh menambahkan cek kecil untuk siklus symlink , serta memijat output sedikit.

Akhirnya, fungsi untuk mengkanonik jalur:

canonicalize_path() {
    if [ -d "$1" ]; then
        _canonicalize_dir_path "$1"
    else
        _canonicalize_file_path "$1"
    fi
}   

_canonicalize_dir_path() {
    (cd "$1" 2>/dev/null && pwd -P) 
}           

_canonicalize_file_path() {
    local dir file
    dir=$(dirname -- "$1")
    file=$(basename -- "$1")
    (cd "$dir" 2>/dev/null && printf '%s/%s\n' "$(pwd -P)" "$file")
}

Itu dia, kurang lebih. Cukup sederhana untuk disisipkan ke skrip Anda, tetapi cukup rumit sehingga Anda akan gila untuk mengandalkan kode apa pun yang tidak memiliki tes unit untuk kasus penggunaan Anda.

Satu-liner sederhana di perl yang pasti akan bekerja hampir di mana saja tanpa ketergantungan eksternal:

perl -MCwd -e 'print Cwd::abs_path shift' ~/non-absolute/file

Will dereference symlinks.

Penggunaan dalam skrip bisa seperti ini:

readlinkf(){ perl -MCwd -e 'print Cwd::abs_path shift' "$1";}
ABSPATH="$(readlinkf ./non-absolute/file)"

1. Pasang homebrew
2. Jalankan "brew install coreutils"
3. Jalankan "greadlink -f path"

greadlink adalah readlink gnu yang mengimplementasikan -f. Anda dapat menggunakan macports atau lainnya juga, saya lebih suka homebrew.

Saya membuat sebuah skrip bernama realpath pribadi yang terlihat seperti:

#!/usr/bin/env python
import os.sys
print os.path.realpath(sys.argv[1])

Bagaimana dengan ini?

function readlink() {
  DIR="${1%/*}"
  (cd "$DIR" && echo "$(pwd -P)")
}

Ini adalah fungsi shell portabel yang bisa digunakan di APAPUN shell sebanding Bourne. Ini akan menyelesaikan tanda baca jalur relatif ".. atau." dan tautan simbolik dereferensi.

Jika karena alasan tertentu Anda tidak memiliki perintah realpath (1), atau readlink (1) ini dapat alias.

which realpath || alias realpath='real_path'

Nikmati:

real_path () {
  OIFS=$IFS
  IFS='/'
  for I in $1
  do
    # Resolve relative path punctuation.
    if [ "$I" = "." ] || [ -z "$I" ]
      then continue
    elif [ "$I" = ".." ]
      then FOO="${FOO%%/${FOO##*/}}"
           continue
      else FOO="${FOO}/${I}"
    fi

    ## Resolve symbolic links
    if [ -h "$FOO" ]
    then
    IFS=$OIFS
    set `ls -l "$FOO"`
    while shift ;
    do
      if [ "$1" = "->" ]
        then FOO=$2
             shift $#
             break
      fi
    done
    IFS='/'
    fi
  done
  IFS=$OIFS
  echo "$FOO"
}

juga, kalau-kalau ada orang yang tertarik di sini adalah bagaimana menerapkan nama samaran dan dirname dalam kode shell 100% murni:

## http://www.opengroup.org/onlinepubs/000095399/functions/dirname.html
# the dir name excludes the least portion behind the last slash.
dir_name () {
  echo "${1%/*}"
}

## http://www.opengroup.org/onlinepubs/000095399/functions/basename.html
# the base name excludes the greatest portion in front of the last slash.
base_name () {
  echo "${1##*/}"
}

Anda dapat menemukan versi terbaru dari kode shell ini di situs google saya: http://sites.google.com/site/jdisnard/realpath

EDIT: Kode ini dilisensikan berdasarkan ketentuan lisensi 2-klausa (gaya freeBSD). Salinan lisensi dapat ditemukan dengan mengikuti hyperlink di atas ke situs saya.

FreeBSD dan OSX memiliki versi statturunan dari NetBSD.

Anda dapat menyesuaikan output dengan sakelar format (lihat halaman manual pada tautan di atas).

%  cd  /service
%  ls -tal 
drwxr-xr-x 22 root wheel 27 Aug 25 10:41 ..
drwx------  3 root wheel  8 Jun 30 13:59 .s6-svscan
drwxr-xr-x  3 root wheel  5 Jun 30 13:34 .
lrwxr-xr-x  1 root wheel 30 Dec 13 2013 clockspeed-adjust -> /var/service/clockspeed-adjust
lrwxr-xr-x  1 root wheel 29 Dec 13 2013 clockspeed-speed -> /var/service/clockspeed-speed
% stat -f%R  clockspeed-adjust
/var/service/clockspeed-adjust
% stat -f%Y  clockspeed-adjust
/var/service/clockspeed-adjust

Beberapa versi OS X stat mungkin tidak memiliki -f%Ropsi untuk format. Dalam hal ini -stat -f%Ymungkin sudah cukup. The -f%Ypilihan akan menunjukkan target symlink, sedangkan-f%R menunjukkan nama path absolut sesuai dengan file.

EDIT:

Jika Anda dapat menggunakan Perl (Darwin / OS X dilengkapi dengan versi terbaru dari perl) maka:

perl -MCwd=abs_path -le 'print abs_path readlink(shift);' linkedfile.txt

akan bekerja.

Cara termudah untuk menyelesaikan masalah ini dan mengaktifkan fungsionalitas readlink pada Mac dengan Homebrew yang diinstal atau FreeBSD adalah dengan menginstal paket 'coreutils'. Mungkin juga diperlukan pada distribusi Linux tertentu dan OS POSIX lainnya.

Sebagai contoh, di FreeBSD 11, saya menginstal dengan memohon:

# pkg install coreutils

Pada MacOS dengan Homebrew, perintahnya adalah:

$ brew install coreutils

Tidak begitu yakin mengapa jawaban lain begitu rumit, hanya itu yang ada di sana. File-file tidak di tempat yang berbeda, mereka hanya belum diinstal.

Mulai Perbarui

Ini adalah masalah yang sering terjadi sehingga kami mengumpulkan perpustakaan Bash 4 untuk penggunaan gratis (Lisensi MIT) yang disebut realpath-lib . Ini dirancang untuk mengemulasi readlink -f secara default dan menyertakan dua test suite untuk memverifikasi (1) bahwa ia berfungsi untuk sistem unix yang diberikan dan (2) terhadap readlink -f jika diinstal (tetapi ini tidak diperlukan). Selain itu, ini dapat digunakan untuk menyelidiki, mengidentifikasi, dan melepaskan symlink yang dalam dan rusak, sehingga dapat menjadi alat yang berguna untuk mendiagnosis masalah fisik dan simbolik direktori dan file yang bersarang. Hal ini dapat ditemukan di github.com atau bitbucket.org .

Akhiri Pembaruan

Solusi lain yang sangat ringkas dan efisien yang tidak bergantung pada apa pun kecuali Bash adalah:

function get_realpath() {

    [[ ! -f "$1" ]] && return 1 # failure : file does not exist.
    [[ -n "$no_symlinks" ]] && local pwdp='pwd -P' || local pwdp='pwd' # do symlinks.
    echo "$( cd "$( echo "${1%/*}" )" 2>/dev/null; $pwdp )"/"${1##*/}" # echo result.
    return 0 # success

}

Ini juga termasuk pengaturan lingkungan no_symlinksyang menyediakan kemampuan untuk menyelesaikan symlink ke sistem fisik. Selama no_symlinksdiatur ke sesuatu, yaitu no_symlinks='on'symlink akan diselesaikan ke sistem fisik. Kalau tidak mereka akan diterapkan (pengaturan default).

Ini harus bekerja pada sistem apa pun yang menyediakan Bash, dan akan mengembalikan kode keluar yang kompatibel dengan Bash untuk tujuan pengujian.

Sudah ada banyak jawaban, tetapi tidak ada yang berhasil untuk saya ... Jadi ini yang saya gunakan sekarang.

readlink_f() {
  local target="$1"
  [ -f "$target" ] || return 1 #no nofile

  while [ -L "$target" ]; do
    target="$(readlink "$target")" 
  done
  echo "$(cd "$(dirname "$target")"; pwd -P)/$target"
}

Cara malas yang bekerja untuk saya,

$ brew install coreutils
$ ln -s /usr/local/bin/greadlink /usr/local/bin/readlink
$ which readlink
/usr/local/bin/readlink
/usr/bin/readlink

Lebih baik terlambat daripada tidak, kurasa. Saya termotivasi untuk mengembangkan ini secara khusus karena skrip Fedora saya tidak berfungsi pada Mac. Masalahnya adalah dependensi dan Bash. Mac tidak memilikinya, atau jika ya, sering ada di tempat lain (jalur lain). Manipulasi jalur ketergantungan dalam skrip Bash lintas-platform adalah sakit kepala paling-paling dan risiko keamanan paling buruk - jadi sebaiknya hindari penggunaannya, jika mungkin.

Fungsi get_realpath () di bawah ini sederhana, Bash-centric, dan tidak ada ketergantungan yang diperlukan. Saya hanya menggunakan echo dan cd bawaan Bash . Ini juga cukup aman, karena semuanya diuji pada setiap tahap dan mengembalikan kondisi kesalahan.

Jika Anda tidak ingin mengikuti symlink, maka letakkan set -P di bagian depan skrip, tetapi jika tidak cd akan menyelesaikan symlink secara default. Ini telah diuji dengan argumen file yang {absolute | kerabat | symlink | local} dan mengembalikan path absolut ke file. Sejauh ini kami tidak punya masalah dengan itu.

function get_realpath() {

if [[ -f "$1" ]]
then
    # file *must* exist
    if cd "$(echo "${1%/*}")" &>/dev/null
    then
        # file *may* not be local
        # exception is ./file.ext
        # try 'cd .; cd -;' *works!*
        local tmppwd="$PWD"
        cd - &>/dev/null
    else
        # file *must* be local
        local tmppwd="$PWD"
    fi
else
    # file *cannot* exist
    return 1 # failure
fi

# reassemble realpath
echo "$tmppwd"/"${1##*/}"
return 0 # success

}

Anda dapat menggabungkan ini dengan fungsi lain get_dirname, get_filename, get_stemname dan validate_path. Ini dapat ditemukan di repositori GitHub kami sebagai realpath-lib (pengungkapan penuh - ini adalah produk kami tetapi kami menawarkannya secara gratis kepada komunitas tanpa batasan). Itu juga bisa berfungsi sebagai alat instruksional - itu didokumentasikan dengan baik.

Kami telah mencoba yang terbaik untuk menerapkan praktik yang disebut 'Bash modern', tetapi Bash adalah subjek besar dan saya yakin akan selalu ada ruang untuk perbaikan. Ini membutuhkan Bash 4+ tetapi bisa dibuat untuk bekerja dengan versi yang lebih lama jika masih ada.

Karena pekerjaan saya digunakan oleh orang-orang dengan Linux non-BSD dan juga macOS, saya telah memilih untuk menggunakan alias ini dalam skrip build kami ( sedtermasuk karena memiliki masalah yang sama):

##
# If you're running macOS, use homebrew to install greadlink/gsed first:
#   brew install coreutils
#
# Example use:
#   # Gets the directory of the currently running script
#   dotfilesDir=$(dirname "$(globalReadlink -fm "$0")")
#   alias al='pico ${dotfilesDir}/aliases.local'
##

function globalReadlink () {
  # Use greadlink if on macOS; otherwise use normal readlink
  if [[ $OSTYPE == darwin* ]]; then
    greadlink "$@"
  else
    readlink "$@"
  fi
}

function globalSed () {
  # Use gsed if on macOS; otherwise use normal sed
  if [[ $OSTYPE == darwin* ]]; then
    gsed "$@"
  else
    sed "$@"
  fi
}

Pemeriksaan opsional yang dapat Anda tambahkan untuk menginstal dependensi homebrew + coreutils secara otomatis :

if [[ "$OSTYPE" == "darwin"* ]]; then
  # Install brew if needed
  if [ -z "$(which brew)" ]; then 
    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"; 
  fi
  # Check for coreutils
  if [ -z "$(brew ls coreutils)" ]; then
    brew install coreutils
  fi
fi

Saya kira benar-benar "global" perlu memeriksa orang lain ... tapi itu mungkin mendekati tanda 80/20.

Penjelasan

coreutils adalah brewpaket yang menginstal utilitas inti GNU / Linux yang sesuai dengan implementasi Mac OSX sehingga Anda dapat menggunakannya

Anda mungkin menemukan program atau utilitas pada sistem mac osx Anda yang tampaknya mirip dengan Linux coreutils ("Core Utilities") namun mereka berbeda dalam beberapa hal (seperti memiliki flag yang berbeda).

Ini karena implementasi Mac OSX dari alat-alat ini berbeda. Untuk mendapatkan perilaku mirip GNU / Linux asli, Anda dapat menginstal coreutilspaket melalui brewsistem manajemen paket.

Ini akan menginstal utilitas inti yang sesuai, diawali oleh g. Misalnya untuk readlink, Anda akan menemukan greadlinkprogram yang sesuai .

Untuk membuat readlinkkinerja seperti implementasi GNU readlink( greadlink), Anda dapat membuat alias sederhana setelah Anda menginstal coreutils.

Penerapan

1. Pasang brew

Ikuti instruksi di https://brew.sh/

2. Instal paket coreutils

brew install coreutils

3. Buat Alias

Anda dapat menempatkan alias Anda di ~ / .bashrc, ~ / .bash_profile, atau di mana pun Anda terbiasa menyimpan alias bash Anda. Saya pribadi menyimpan milik saya di ~ / .bashrc

alias readlink=greadlink

Anda dapat membuat alias serupa untuk coreutils lainnya seperti gmv, gdu, gdf, dan sebagainya. Tetapi berhati-hatilah bahwa perilaku GNU pada mesin mac mungkin membingungkan bagi orang lain yang terbiasa bekerja dengan coreutils asli, atau mungkin berperilaku dengan cara yang tidak terduga pada sistem mac Anda.

Saya menulis utilitas realpath untuk OS X yang dapat memberikan hasil yang sama seperti readlink -f.

Berikut ini sebuah contoh:

(jalcazar@mac tmp)$ ls -l a
lrwxrwxrwx 1 jalcazar jalcazar 11  8月 25 19:29 a -> /etc/passwd

(jalcazar@mac tmp)$ realpath a
/etc/passwd

Jika Anda menggunakan MacPorts, Anda dapat menginstalnya dengan perintah berikut: sudo port selfupdate && sudo port install realpath.

Benar-benar platform-indpendent juga akan menjadi R-onliner ini

readlink(){ RScript -e "cat(normalizePath(commandArgs(T)[1]))" "$1";}

Untuk benar-benar meniru readlink -f <path>, $ 2 dan bukan $ 1 harus digunakan.

readlink -fImplementasi yang sesuai dengan POSIX untuk skrip shell POSIX

https://github.com/ko1nksm/readlinkf

Ini adalah POSIX compliant (tidak ada bashism). Tidak menggunakan juga readlinktidak realpath. Saya telah memverifikasi bahwa persis sama dengan membandingkan dengan GNU readlink -f(lihat hasil tes ). Ini memiliki penanganan kesalahan dan kinerja yang baik. Anda dapat dengan aman mengganti dari readlink -f. Lisensi tersebut adalah CC0, sehingga Anda dapat menggunakannya untuk proyek apa pun.

# POSIX compliant version
readlinkf_posix() {
  [ "${1:-}" ] || return 1
  target=$1 max_symlinks=10 CDPATH=''

  [ -e "${target%/}" ] || target=${1%"${1##*[!/]}"} # trim trailing slashes
  [ -d "${target:-/}" ] && target="$target/"

  cd -P . 2>/dev/null || return 1
  while [ "$max_symlinks" -gt 0 ] && max_symlinks=$((max_symlinks - 1)); do
    if [ ! "$target" = "${target%/*}" ]; then
      cd -P "${target%/*}/" 2>/dev/null || break
      target=${target##*/}
    fi

    if [ ! -L "$target" ]; then
      target="${PWD%/}${target:+/}$target"
      printf '%s\n' "${target:-/}"
      return 0
    fi

    # `ls -dl` format: "%s %u %s %s %u %s %s -> %s\n",
    #   <file mode>, <number of links>, <owner name>, <group name>,
    #   <size>, <date and time>, <pathname of link>, <contents of link>
    # https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html
    link=$(ls -dl "$target" 2>/dev/null) || break
    target=${link#*" $target -> "}
  done
  return 1
}

Silakan merujuk ke kode terbaru. Mungkin beberapa diperbaiki.

Perl memiliki fungsi readlink (mis. Bagaimana cara menyalin tautan simbolik di Perl? ). Ini berfungsi di sebagian besar platform, termasuk OS X:

perl -e "print readlink '/path/to/link'"

Sebagai contoh:

$ mkdir -p a/b/c
$ ln -s a/b/c x
$ perl -e "print readlink 'x'"
a/b/c

Jawaban dari @Keith Smith memberikan loop tak terbatas.

Inilah jawaban saya, yang saya gunakan hanya pada SunOS (SunOS kehilangan begitu banyak perintah POSIX dan GNU).

Ini adalah file skrip yang harus Anda masukkan ke dalam salah satu dari direktori $ PATH Anda:

#!/bin/sh
! (($#)) && echo -e "ERROR: readlink <link to analyze>" 1>&2 && exit 99

link="$1"
while [ -L "$link" ]; do
  lastLink="$link"
  link=$(/bin/ls -ldq "$link")
  link="${link##* -> }"
  link=$(realpath "$link")
  [ "$link" == "$lastlink" ] && echo -e "ERROR: link loop detected on $link" 1>&2 && break
done

echo "$link"

Inilah yang saya gunakan:

stat -f %N $your_path

Path ke readlink berbeda antara sistem saya dan Anda. Silakan coba tentukan path lengkap:

/sw/sbin/readlink -f