File Explorer

/proc/self/root/proc/thread-self/root/proc/thread-self/root/lib/python3.9/site-packages/dnf

This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.

lock.py5.2 KB · 149 lines
# lock.py# DNF Locking Subsystem.## Copyright (C) 2013-2016 Red Hat, Inc.## This copyrighted material is made available to anyone wishing to use,# modify, copy, or redistribute it subject to the terms and conditions of# the GNU General Public License v.2, or (at your option) any later version.# This program is distributed in the hope that it will be useful, but WITHOUT# ANY WARRANTY expressed or implied, including the implied warranties of# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General# Public License for more details.  You should have received a copy of the# GNU General Public License along with this program; if not, write to the# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the# source code or documentation are not subject to the GNU General Public# License and may only be used or replicated with the express permission of# Red Hat, Inc.# from __future__ import absolute_importfrom __future__ import unicode_literalsfrom dnf.exceptions import ProcessLockError, ThreadLockError, LockErrorfrom dnf.i18n import _from dnf.yum import miscimport dnf.loggingimport dnf.utilimport errnoimport fcntlimport hashlibimport loggingimport osimport threadingimport time logger = logging.getLogger("dnf") def _fit_lock_dir(dir_):    if not dnf.util.am_i_root():        # for regular users the best we currently do is not to clash with        # another DNF process of the same user. Since dir_ is quite definitely        # not writable for us, yet significant, use its hash:        hexdir = hashlib.sha1(dir_.encode('utf-8')).hexdigest()        dir_ = os.path.join(misc.getCacheDir(), 'locks', hexdir)    return dir_ def build_download_lock(cachedir, exit_on_lock):    return ProcessLock(os.path.join(_fit_lock_dir(cachedir), 'download_lock.pid'),                       'cachedir', not exit_on_lock) def build_metadata_lock(cachedir, exit_on_lock):    return ProcessLock(os.path.join(_fit_lock_dir(cachedir), 'metadata_lock.pid'),                       'metadata', not exit_on_lock)  def build_rpmdb_lock(persistdir, exit_on_lock):    return ProcessLock(os.path.join(_fit_lock_dir(persistdir), 'rpmdb_lock.pid'),                       'RPMDB', not exit_on_lock)  def build_log_lock(logdir, exit_on_lock):    return ProcessLock(os.path.join(_fit_lock_dir(logdir), 'log_lock.pid'),                       'log', not exit_on_lock)  class ProcessLock(object):    def __init__(self, target, description, blocking=False):        self.blocking = blocking        self.count = 0        self.description = description        self.target = target        self.thread_lock = threading.RLock()     def _lock_thread(self):        if not self.thread_lock.acquire(blocking=False):            msg = '%s already locked by a different thread' % self.description            raise ThreadLockError(msg)        self.count += 1     def _try_lock(self, pid):        fd = os.open(self.target, os.O_CREAT | os.O_RDWR, 0o644)         try:            try:                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)            except OSError as e:                if e.errno == errno.EWOULDBLOCK:                    return -1                raise             old_pid = os.read(fd, 20)            if len(old_pid) == 0:                # empty file, write our pid                os.write(fd, str(pid).encode('utf-8'))                return pid             try:                old_pid = int(old_pid)            except ValueError:                msg = _('Malformed lock file found: %s.\n'                        'Ensure no other dnf/yum process is running and '                        'remove the lock file manually or run '                        'systemd-tmpfiles --remove dnf.conf.') % (self.target)                raise LockError(msg)             if old_pid == pid:                # already locked by this process                return pid             if not os.access('/proc/%d/stat' % old_pid, os.F_OK):                # locked by a dead process, write our pid                os.lseek(fd, 0, os.SEEK_SET)                os.ftruncate(fd, 0)                os.write(fd, str(pid).encode('utf-8'))                return pid             return old_pid         finally:            os.close(fd)     def _unlock_thread(self):        self.count -= 1        self.thread_lock.release()     def __enter__(self):        dnf.util.ensure_dir(os.path.dirname(self.target))        self._lock_thread()        prev_pid = -1        my_pid = os.getpid()        pid = self._try_lock(my_pid)        while pid != my_pid:            if pid != -1:                if not self.blocking:                    self._unlock_thread()                    msg = '%s already locked by %d' % (self.description, pid)                    raise ProcessLockError(msg, pid)                if prev_pid != pid:                    msg = _('Waiting for process with pid %d to finish.') % (pid)                    logger.info(msg)                    prev_pid = pid            time.sleep(1)            pid = self._try_lock(my_pid)     def __exit__(self, *exc_args):        if self.count == 1:            os.unlink(self.target)        self._unlock_thread()