Kaputte symlinks mit Python

Einer gemeinsamen Python zu sagen ist, dass es einfacher ist, um Vergebung zu bitten als Zustimmung. Ich bin zwar kein fan von dieser Aussage im wirklichen Leben, es gilt in vielen Fällen. In der Regel will man vermeiden, dass code, Ketten zwei-system-Aufrufe auf die gleiche Datei, weil Sie nie wissen, was passieren wird, um die Datei zwischen Ihrem zwei Anrufe in Ihrem code.

Ein typischer Fehler ist, etwas zu schreiben, wie:

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

Den zweiten Anruf (os.unlink) kann fehlschlagen, wenn etwas anderes gelöscht, es nach der if-test, der eine Ausnahme auslösen, und beenden Sie den rest der Funktion auszuführen. (Man könnte denken, dies nicht im wirklichen Leben passieren, aber wir fischten ein bug wie der, dass aus unserer codebase Letzte Woche - und es war die Art von Fehler, dass Links ein paar Programmierer, kratzen sich den Kopf und fordern 'Heisenbug' für die letzten paar Monate)

So, in deinem speziellen Fall, würde ich wohl auch tun:

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

Ärgernis hier ist, dass die stat wieder die gleichen Fehler-code für einen symbolischen Link, die ist einfach nicht da und eine kaputte symlink.

So, ich denke, Sie haben keine andere Wahl als zu brechen, die die Unteilbarkeit, und etwas tun, wie

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

InformationsquelleAutor der Antwort Thomas Vander Stichele

Dies ist nicht atomar, aber es funktioniert.

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

In der Tat von RTFM
(Lesen Sie das fantastische Handbuch) wir sehen

os.Pfad.exists(Pfad)

True zurück, wenn der Pfad bezieht sich auf einen bestehenden Pfad. Gibt False für fehlerhafte symbolische links.

Er sagt auch:

Auf einigen Plattformen diese Funktion kann False zurückgeben, wenn die Erlaubnis nicht erteilt wird, zur Ausführung os.stat() auf die gewünschte Datei, auch wenn der Pfad existiert physisch.

Also, wenn Sie sind besorgt über die Berechtigungen, die Sie hinzufügen sollte, andere Bestimmungen.

InformationsquelleAutor der Antwort am70

os.Pfad

Sie können versuchen, mit realpath() zu bekommen, was der symlink zeigt, dann versuchen zu bestimmen, ob Sie eine gültige Datei verwendet, ist Datei.

(Ich bin nicht in der Lage, um zu versuchen, die im moment, also müssen Sie spielen, um mit ihm und sehen, was Sie erhalten)

InformationsquelleAutor der Antwort Jason Baker

Ich hatte ein ähnliches problem: wie fangen broken symlinks, auch wenn Sie sich in einige übergeordnete dir? Wollte ich auch melden Sie sich für alle von Ihnen (in einer Anwendung, die den Umgang mit einem ziemlich großen Anzahl von Dateien), aber ohne allzu viele Wiederholungen.

Hier ist was ich kam mit, einschließlich unit-tests.

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)

Unit-tests:

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()

InformationsquelleAutor der Antwort Pierre D