Найти символические ссылки с Python

Распространенная поговорка Python гласит, что легче попросить прощения, чем разрешения. Хотя я не поклонник этого утверждения в реальной жизни, оно действительно применимо во многих случаях. Обычно вы хотите избежать кода, который связывает два системных вызова в один и тот же файл, потому что вы никогда не знаете, что произойдет с файлом между двумя вызовами в вашем коде.

Типичная ошибка-написать что-то вроде :

if os.path.exists(path):
    os.unlink(path)

Второй вызов (os.unlink) может завершиться неудачей, если что-то другое удалит его после вашего теста if, вызовет исключение и остановит выполнение rest вашей функции. (Вы можете подумать, что это не происходит в реальной жизни, но мы только что выловили еще одну такую ошибку из нашей кодовой базы на прошлой неделе - и это была та ошибка, которая заставила нескольких программистов почесать голову и заявить 'Heisenbug' в течение последних нескольких месяцев)

Так что, в вашем конкретном случае, я бы, вероятно, сделал:

try:
    os.stat(path)
except OSError, e:
    if e.errno == errno.ENOENT:
        print 'path %s does not exist or is a broken symlink' % path
    else:
        raise e

Досада здесь заключается в том, что stat возвращает один и тот же код ошибки для символьной ссылки, которой просто нет, и сломанной символьной ссылки.

Так что, я думаю, у вас нет другого выбора, кроме как сломать атомарность и сделать что-то вроде

if not os.path.exists(os.readlink(path)):
    print 'path %s is a broken symlink' % path

os.lstat() может оказаться полезным. Если lstat() преуспевает, а stat() терпит неудачу, то это, вероятно, сломанная ссылка.

Это не атомно, но работает.

os.path.islink(filename) and not os.path.exists(filename)

Действительно, по RTFM (читая фантастическое руководство) мы видим

os.path.exists(path)

Возвращает True, если path ссылается на существующий путь. Возвращает False для сломанных символьных ссылок.

В нем также говорится::

На некоторых платформах эта функция может возвращать False, если не предоставлено разрешение на выполнение os.stat() для запрошенного файла, даже если путь физически существует.

Поэтому, если вы беспокоитесь о разрешениях, вам следует добавить другие предложения.

Могу ли я упомянуть тестирование жестких ссылок без python? /bin/test имеет условие FILE1-ef FILE2, которое является истинным, когда файлы совместно используют индекс.

Поэтому что-то вроде find . -type f -exec test \{} -ef /path/to/file \; -print работает для жесткого тестирования ссылок на конкретный файл.

Что приводит меня к чтению man test и упоминаний -L и -h , которые оба работают на одном файле и возвращают true, если этот файл является символической ссылкой, однако это не говорит вам, если цель отсутствует.

Я действительно обнаружил, что head -0 FILE1 вернет код выхода 0 , если файл можно открыть, и 1 , если он не может, что в случае символической ссылки на обычный файл работает как тест на то, можно ли прочитать его цель.

os.path

Вы можете попробовать использовать realpath(), чтобы получить то, на что указывает символическая ссылка, а затем попытаться определить, является ли это допустимый файл, используя is file.

(В данный момент я не могу попробовать это, поэтому вам придется поиграть с ним и посмотреть, что вы получите)

Я не python парень, но это выглядит как os.readlink()? Логика, которую я бы использовал в perl, состоит в том, чтобы использовать readlink() для поиска цели и использовать stat() для проверки, существует ли цель.

Edit: я ударил некоторые perl, что Демос readlink. Я считаю, что статы perl и readlink, а также python и os.stat() и os.readlink() являются обоими оболочками для системных вызовов, поэтому это должно быть разумным переводом и доказательством кода концепции:

wembley 0 /home/jj33/swap > cat p
my $f = shift;

while (my $l = readlink($f)) {
  print "$f -> $l\n";
  $f = $l;
}

if (!-e $f) {
  print "$f doesn't exist\n";
}
wembley 0 /home/jj33/swap > ls -l | grep ^l
lrwxrwxrwx    1 jj33  users          17 Aug 21 14:30 link -> non-existant-file
lrwxrwxrwx    1 root     users          31 Oct 10  2007 mm -> ../systems/mm/20071009-rewrite//
lrwxrwxrwx    1 jj33  users           2 Aug 21 14:34 mmm -> mm/
wembley 0 /home/jj33/swap > perl p mm
mm -> ../systems/mm/20071009-rewrite/
wembley 0 /home/jj33/swap > perl p mmm
mmm -> mm
mm -> ../systems/mm/20071009-rewrite/
wembley 0 /home/jj33/swap > perl p link
link -> non-existant-file
non-existant-file doesn't exist
wembley 0 /home/jj33/swap >

У меня была похожая проблема: как поймать сломанные символьные ссылки, даже если они встречаются в каком-то Родительском dir? Я также хотел записать их все (в приложении, имеющем дело с довольно большим количеством файлов), но без слишком большого количества повторов.

Вот что я придумал, включая модульные тесты.

fileutil.py :

import os
from functools import lru_cache
import logging

logger = logging.getLogger(__name__)

@lru_cache(maxsize=2000)
def check_broken_link(filename):
    """
    Check for broken symlinks, either at the file level, or in the
    hierarchy of parent dirs.
    If it finds a broken link, an ERROR message is logged.
    The function is cached, so that the same error messages are not repeated.

    Args:
        filename: file to check

    Returns:
        True if the file (or one of its parents) is a broken symlink.
        False otherwise (i.e. either it exists or not, but no element
        on its path is a broken link).

    """
    if os.path.isfile(filename) or os.path.isdir(filename):
        return False
    if os.path.islink(filename):
        # there is a symlink, but it is dead (pointing nowhere)
        link = os.readlink(filename)
        logger.error('broken symlink: {} -> {}'.format(filename, link))
        return True
    # ok, we have either:
    #   1. a filename that simply doesn't exist (but the containing dir
           does exist), or
    #   2. a broken link in some parent dir
    parent = os.path.dirname(filename)
    if parent == filename:
        # reached root
        return False
    return check_broken_link(parent)

Модульное тестирование:

import logging
import shutil
import tempfile
import os

import unittest
from ..util import fileutil


class TestFile(unittest.TestCase):

    def _mkdir(self, path, create=True):
        d = os.path.join(self.test_dir, path)
        if create:
            os.makedirs(d, exist_ok=True)
        return d

    def _mkfile(self, path, create=True):
        f = os.path.join(self.test_dir, path)
        if create:
            d = os.path.dirname(f)
            os.makedirs(d, exist_ok=True)
            with open(f, mode='w') as fp:
                fp.write('hello')
        return f

    def _mklink(self, target, path):
        f = os.path.join(self.test_dir, path)
        d = os.path.dirname(f)
        os.makedirs(d, exist_ok=True)
        os.symlink(target, f)
        return f

    def setUp(self):
        # reset the lru_cache of check_broken_link
        fileutil.check_broken_link.cache_clear()

        # create a temporary directory for our tests
        self.test_dir = tempfile.mkdtemp()

        # create a small tree of dirs, files, and symlinks
        self._mkfile('a/b/c/foo.txt')
        self._mklink('b', 'a/x')
        self._mklink('b/c/foo.txt', 'a/f')
        self._mklink('../..', 'a/b/c/y')
        self._mklink('not_exist.txt', 'a/b/c/bad_link.txt')
        bad_path = self._mkfile('a/XXX/c/foo.txt', create=False)
        self._mklink(bad_path, 'a/b/c/bad_path.txt')
        self._mklink('not_a_dir', 'a/bad_dir')

    def tearDown(self):
        # Remove the directory after the test
        shutil.rmtree(self.test_dir)

    def catch_check_broken_link(self, expected_errors, expected_result, path):
        filename = self._mkfile(path, create=False)
        with self.assertLogs(level='ERROR') as cm:
            result = fileutil.check_broken_link(filename)
            logging.critical('nothing')  # trick: emit one extra message, so the with assertLogs block doesn't fail
        error_logs = [r for r in cm.records if r.levelname is 'ERROR']
        actual_errors = len(error_logs)
        self.assertEqual(expected_result, result, msg=path)
        self.assertEqual(expected_errors, actual_errors, msg=path)

    def test_check_broken_link_exists(self):
        self.catch_check_broken_link(0, False, 'a/b/c/foo.txt')
        self.catch_check_broken_link(0, False, 'a/x/c/foo.txt')
        self.catch_check_broken_link(0, False, 'a/f')
        self.catch_check_broken_link(0, False, 'a/b/c/y/b/c/y/b/c/foo.txt')

    def test_check_broken_link_notfound(self):
        self.catch_check_broken_link(0, False, 'a/b/c/not_found.txt')

    def test_check_broken_link_badlink(self):
        self.catch_check_broken_link(1, True, 'a/b/c/bad_link.txt')
        self.catch_check_broken_link(0, True, 'a/b/c/bad_link.txt')

    def test_check_broken_link_badpath(self):
        self.catch_check_broken_link(1, True, 'a/b/c/bad_path.txt')
        self.catch_check_broken_link(0, True, 'a/b/c/bad_path.txt')

    def test_check_broken_link_badparent(self):
        self.catch_check_broken_link(1, True, 'a/bad_dir/c/foo.txt')
        self.catch_check_broken_link(0, True, 'a/bad_dir/c/foo.txt')
        # bad link, but shouldn't log a new error:
        self.catch_check_broken_link(0, True, 'a/bad_dir/c')
        # bad link, but shouldn't log a new error:
        self.catch_check_broken_link(0, True, 'a/bad_dir')

if __name__ == '__main__':
    unittest.main()