123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235 |
- #
- # SPDX-License-Identifier: GPL-2.0-only
- #
- # Based on standard python library functions but avoid
- # repeated stat calls. Its assumed the files will not change from under us
- # so we can cache stat calls.
- #
- import os
- import errno
- import stat as statmod
- class CachedPath(object):
- def __init__(self):
- self.statcache = {}
- self.lstatcache = {}
- self.normpathcache = {}
- return
- def updatecache(self, x):
- x = self.normpath(x)
- if x in self.statcache:
- del self.statcache[x]
- if x in self.lstatcache:
- del self.lstatcache[x]
- def normpath(self, path):
- if path in self.normpathcache:
- return self.normpathcache[path]
- newpath = os.path.normpath(path)
- self.normpathcache[path] = newpath
- return newpath
- def _callstat(self, path):
- if path in self.statcache:
- return self.statcache[path]
- try:
- st = os.stat(path)
- self.statcache[path] = st
- return st
- except os.error:
- self.statcache[path] = False
- return False
- # We might as well call lstat and then only
- # call stat as well in the symbolic link case
- # since this turns out to be much more optimal
- # in real world usage of this cache
- def callstat(self, path):
- path = self.normpath(path)
- self.calllstat(path)
- return self.statcache[path]
- def calllstat(self, path):
- path = self.normpath(path)
- if path in self.lstatcache:
- return self.lstatcache[path]
- #bb.error("LStatpath:" + path)
- try:
- lst = os.lstat(path)
- self.lstatcache[path] = lst
- if not statmod.S_ISLNK(lst.st_mode):
- self.statcache[path] = lst
- else:
- self._callstat(path)
- return lst
- except (os.error, AttributeError):
- self.lstatcache[path] = False
- self.statcache[path] = False
- return False
- # This follows symbolic links, so both islink() and isdir() can be true
- # for the same path ono systems that support symlinks
- def isfile(self, path):
- """Test whether a path is a regular file"""
- st = self.callstat(path)
- if not st:
- return False
- return statmod.S_ISREG(st.st_mode)
- # Is a path a directory?
- # This follows symbolic links, so both islink() and isdir()
- # can be true for the same path on systems that support symlinks
- def isdir(self, s):
- """Return true if the pathname refers to an existing directory."""
- st = self.callstat(s)
- if not st:
- return False
- return statmod.S_ISDIR(st.st_mode)
- def islink(self, path):
- """Test whether a path is a symbolic link"""
- st = self.calllstat(path)
- if not st:
- return False
- return statmod.S_ISLNK(st.st_mode)
- # Does a path exist?
- # This is false for dangling symbolic links on systems that support them.
- def exists(self, path):
- """Test whether a path exists. Returns False for broken symbolic links"""
- if self.callstat(path):
- return True
- return False
- def lexists(self, path):
- """Test whether a path exists. Returns True for broken symbolic links"""
- if self.calllstat(path):
- return True
- return False
- def stat(self, path):
- return self.callstat(path)
- def lstat(self, path):
- return self.calllstat(path)
- def walk(self, top, topdown=True, onerror=None, followlinks=False):
- # Matches os.walk, not os.path.walk()
- # We may not have read permission for top, in which case we can't
- # get a list of the files the directory contains. os.path.walk
- # always suppressed the exception then, rather than blow up for a
- # minor reason when (say) a thousand readable directories are still
- # left to visit. That logic is copied here.
- try:
- names = os.listdir(top)
- except os.error as err:
- if onerror is not None:
- onerror(err)
- return
- dirs, nondirs = [], []
- for name in names:
- if self.isdir(os.path.join(top, name)):
- dirs.append(name)
- else:
- nondirs.append(name)
- if topdown:
- yield top, dirs, nondirs
- for name in dirs:
- new_path = os.path.join(top, name)
- if followlinks or not self.islink(new_path):
- for x in self.walk(new_path, topdown, onerror, followlinks):
- yield x
- if not topdown:
- yield top, dirs, nondirs
- ## realpath() related functions
- def __is_path_below(self, file, root):
- return (file + os.path.sep).startswith(root)
- def __realpath_rel(self, start, rel_path, root, loop_cnt, assume_dir):
- """Calculates real path of symlink 'start' + 'rel_path' below
- 'root'; no part of 'start' below 'root' must contain symlinks. """
- have_dir = True
- for d in rel_path.split(os.path.sep):
- if not have_dir and not assume_dir:
- raise OSError(errno.ENOENT, "no such directory %s" % start)
- if d == os.path.pardir: # '..'
- if len(start) >= len(root):
- # do not follow '..' before root
- start = os.path.dirname(start)
- else:
- # emit warning?
- pass
- else:
- (start, have_dir) = self.__realpath(os.path.join(start, d),
- root, loop_cnt, assume_dir)
- assert(self.__is_path_below(start, root))
- return start
- def __realpath(self, file, root, loop_cnt, assume_dir):
- while self.islink(file) and len(file) >= len(root):
- if loop_cnt == 0:
- raise OSError(errno.ELOOP, file)
- loop_cnt -= 1
- target = os.path.normpath(os.readlink(file))
-
- if not os.path.isabs(target):
- tdir = os.path.dirname(file)
- assert(self.__is_path_below(tdir, root))
- else:
- tdir = root
- file = self.__realpath_rel(tdir, target, root, loop_cnt, assume_dir)
- try:
- is_dir = self.isdir(file)
- except:
- is_dir = False
- return (file, is_dir)
- def realpath(self, file, root, use_physdir = True, loop_cnt = 100, assume_dir = False):
- """ Returns the canonical path of 'file' with assuming a
- toplevel 'root' directory. When 'use_physdir' is set, all
- preceding path components of 'file' will be resolved first;
- this flag should be set unless it is guaranteed that there is
- no symlink in the path. When 'assume_dir' is not set, missing
- path components will raise an ENOENT error"""
- root = os.path.normpath(root)
- file = os.path.normpath(file)
- if not root.endswith(os.path.sep):
- # letting root end with '/' makes some things easier
- root = root + os.path.sep
- if not self.__is_path_below(file, root):
- raise OSError(errno.EINVAL, "file '%s' is not below root" % file)
- try:
- if use_physdir:
- file = self.__realpath_rel(root, file[(len(root) - 1):], root, loop_cnt, assume_dir)
- else:
- file = self.__realpath(file, root, loop_cnt, assume_dir)[0]
- except OSError as e:
- if e.errno == errno.ELOOP:
- # make ELOOP more readable; without catching it, there will
- # be printed a backtrace with 100s of OSError exceptions
- # else
- raise OSError(errno.ELOOP,
- "too much recursions while resolving '%s'; loop in '%s'" %
- (file, e.strerror))
- raise
- return file
|