comparison mercurial/lock.py @ 43076:2372284d9457

formatting: blacken the codebase

This is using my patch to black
(https://github.com/psf/black/pull/826) so we don't un-wrap collection
literals.

Done with:

  hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S

# skip-blame mass-reformatting only

# no-check-commit reformats foo_bar functions

Differential Revision: https://phab.mercurial-scm.org/D6971

43075:57875cf423c9

    error,
    pycompat,
    util,
)

from .utils import (
    procutil,
)

def _getlockprefix():
    """Return a string which is used to differentiate pid namespaces

    It's useful to detect "dead" processes and remove stale locks with

            result += '/%x' % os.stat('/proc/self/ns/pid').st_ino
        except OSError as ex:
            if ex.errno not in (errno.ENOENT, errno.EACCES, errno.ENOTDIR):
                raise
    return result

@contextlib.contextmanager
def _delayedinterrupt():
    """Block signal interrupt while doing something critical

    assertedsigs = []
    blocked = False
    orighandlers = {}

    def raiseinterrupt(num):
        if (num == getattr(signal, 'SIGINT', None) or
            num == getattr(signal, 'CTRL_C_EVENT', None)):
            raise KeyboardInterrupt
        else:
            raise error.SignalInterrupt
    def catchterm(num, frame):
        if blocked:
            assertedsigs.append(num)
        else:
            raiseinterrupt(num)

                orighandlers[num] = signal.getsignal(num)
        try:
            for num in orighandlers:
                signal.signal(num, catchterm)
        except ValueError:
            pass # in a thread? no luck

        blocked = True
        yield
    finally:
        # no simple way to reliably restore all signal handlers because

        blocked = False
        try:
            for num, handler in orighandlers.items():
                signal.signal(num, handler)
        except ValueError:
            pass # in a thread?

    # re-raise interrupt exception if any, which may be shadowed by a new
    # interrupt occurred while re-raising the first one
    if assertedsigs:
        raiseinterrupt(assertedsigs[0])

def trylock(ui, vfs, lockname, timeout, warntimeout, *args, **kwargs):
    """return an acquired lock or raise an a LockHeld exception

    This function is responsible to issue warnings and or debug messages about

    def printwarning(printer, locker):
        """issue the usual "waiting on lock" message through any channel"""
        # show more details for new-style locks
        if ':' in locker:
            host, pid = locker.split(":", 1)
            msg = (_("waiting for lock on %s held by process %r on host %r\n")
                   % (pycompat.bytestr(l.desc), pycompat.bytestr(pid),
                      pycompat.bytestr(host)))
        else:
            msg = (_("waiting for lock on %s held by %r\n")
                   % (l.desc, pycompat.bytestr(locker)))
        printer(msg)

    l = lock(vfs, lockname, 0, *args, dolock=False, **kwargs)

    debugidx = 0 if (warntimeout and timeout) else -1

            if delay == debugidx:
                printwarning(ui.debug, inst.locker)
            if delay == warningidx:
                printwarning(ui.warn, inst.locker)
            if timeout <= delay:
                raise error.LockHeld(errno.ETIMEDOUT, inst.filename,
                                     l.desc, inst.locker)
            time.sleep(1)
            delay += 1

    l.delay = delay
    if l.delay:

        else:
            ui.debug("got lock after %d seconds\n" % l.delay)
    if l.acquirefn:
        l.acquirefn()
    return l

class lock(object):
    '''An advisory lock held by one process to control access to a set
    of files.  Non-cooperating processes or incorrectly written scripts
    can ignore Mercurial's locking scheme and stomp all over the

    # old-style lock: symlink to pid
    # new-style lock: symlink to hostname:pid

    _host = None

    def __init__(self, vfs, fname, timeout=-1, releasefn=None, acquirefn=None,
                 desc=None, inheritchecker=None, parentlock=None,
                 signalsafe=True, dolock=True):
        self.vfs = vfs
        self.f = fname
        self.held = 0
        self.timeout = timeout
        self.releasefn = releasefn

        self._inherited = False
        if signalsafe:
            self._maybedelayedinterrupt = _delayedinterrupt
        else:
            self._maybedelayedinterrupt = util.nullcontextmanager
        self.postrelease  = []
        self.pid = self._getpid()
        if dolock:
            self.delay = self.lock()
            if self.acquirefn:
                self.acquirefn()

    def __exit__(self, exc_type, exc_value, exc_tb):
        self.release()

    def __del__(self):
        if self.held:
            warnings.warn(r"use lock.release instead of del lock",
                    category=DeprecationWarning,
                    stacklevel=2)

            # ensure the lock will be removed
            # even if recursive locking did occur
            self.held = 1

                if timeout != 0:
                    time.sleep(1)
                    if timeout > 0:
                        timeout -= 1
                    continue
                raise error.LockHeld(errno.ETIMEDOUT, inst.filename, self.desc,
                                     inst.locker)

    def _trylock(self):
        if self.held:
            self.held += 1
            return

                        self._parentheld = True
                        self.held = 1
                        return
                    locker = self._testlock(locker)
                    if locker is not None:
                        raise error.LockHeld(errno.EAGAIN,
                                             self.vfs.join(self.f), self.desc,
                                             locker)
                else:
                    raise error.LockUnavailable(why.errno, why.strerror,
                                                why.filename, self.desc)

        if not self.held:
            # use empty locker to mean "busy for frequent lock/unlock
            # by many processes"
            raise error.LockHeld(errno.EAGAIN,
                                 self.vfs.join(self.f), self.desc, "")

    def _readlock(self):
        """read lock and return its value

        Returns None if no lock exists, pid for old-style locks, and host:pid

        Communicating this string to the subprocess needs to be done separately
        -- typically by an environment variable.
        """
        if not self.held:
            raise error.LockInheritanceContractViolation(
                'inherit can only be called while lock is held')
        if self._inherited:
            raise error.LockInheritanceContractViolation(
                'inherit cannot be called while lock is already inherited')
        if self._inheritchecker is not None:
            self._inheritchecker()
        if self.releasefn:
            self.releasefn()
        if self._parentheld:

                for callback in self.postrelease:
                    callback()
                # Prevent double usage and help clear cycles.
                self.postrelease = None

def release(*locks):
    for lock in locks:
        if lock is not None:
            lock.release()

43076:2372284d9457

    error,
    pycompat,
    util,
)

from .utils import procutil


def _getlockprefix():
    """Return a string which is used to differentiate pid namespaces

    It's useful to detect "dead" processes and remove stale locks with

            result += '/%x' % os.stat('/proc/self/ns/pid').st_ino
        except OSError as ex:
            if ex.errno not in (errno.ENOENT, errno.EACCES, errno.ENOTDIR):
                raise
    return result


@contextlib.contextmanager
def _delayedinterrupt():
    """Block signal interrupt while doing something critical

    assertedsigs = []
    blocked = False
    orighandlers = {}

    def raiseinterrupt(num):
        if num == getattr(signal, 'SIGINT', None) or num == getattr(
            signal, 'CTRL_C_EVENT', None
        ):
            raise KeyboardInterrupt
        else:
            raise error.SignalInterrupt

    def catchterm(num, frame):
        if blocked:
            assertedsigs.append(num)
        else:
            raiseinterrupt(num)

                orighandlers[num] = signal.getsignal(num)
        try:
            for num in orighandlers:
                signal.signal(num, catchterm)
        except ValueError:
            pass  # in a thread? no luck

        blocked = True
        yield
    finally:
        # no simple way to reliably restore all signal handlers because

        blocked = False
        try:
            for num, handler in orighandlers.items():
                signal.signal(num, handler)
        except ValueError:
            pass  # in a thread?

    # re-raise interrupt exception if any, which may be shadowed by a new
    # interrupt occurred while re-raising the first one
    if assertedsigs:
        raiseinterrupt(assertedsigs[0])


def trylock(ui, vfs, lockname, timeout, warntimeout, *args, **kwargs):
    """return an acquired lock or raise an a LockHeld exception

    This function is responsible to issue warnings and or debug messages about

    def printwarning(printer, locker):
        """issue the usual "waiting on lock" message through any channel"""
        # show more details for new-style locks
        if ':' in locker:
            host, pid = locker.split(":", 1)
            msg = _(
                "waiting for lock on %s held by process %r on host %r\n"
            ) % (
                pycompat.bytestr(l.desc),
                pycompat.bytestr(pid),
                pycompat.bytestr(host),
            )
        else:
            msg = _("waiting for lock on %s held by %r\n") % (
                l.desc,
                pycompat.bytestr(locker),
            )
        printer(msg)

    l = lock(vfs, lockname, 0, *args, dolock=False, **kwargs)

    debugidx = 0 if (warntimeout and timeout) else -1

            if delay == debugidx:
                printwarning(ui.debug, inst.locker)
            if delay == warningidx:
                printwarning(ui.warn, inst.locker)
            if timeout <= delay:
                raise error.LockHeld(
                    errno.ETIMEDOUT, inst.filename, l.desc, inst.locker
                )
            time.sleep(1)
            delay += 1

    l.delay = delay
    if l.delay:

        else:
            ui.debug("got lock after %d seconds\n" % l.delay)
    if l.acquirefn:
        l.acquirefn()
    return l


class lock(object):
    '''An advisory lock held by one process to control access to a set
    of files.  Non-cooperating processes or incorrectly written scripts
    can ignore Mercurial's locking scheme and stomp all over the

    # old-style lock: symlink to pid
    # new-style lock: symlink to hostname:pid

    _host = None

    def __init__(
        self,
        vfs,
        fname,
        timeout=-1,
        releasefn=None,
        acquirefn=None,
        desc=None,
        inheritchecker=None,
        parentlock=None,
        signalsafe=True,
        dolock=True,
    ):
        self.vfs = vfs
        self.f = fname
        self.held = 0
        self.timeout = timeout
        self.releasefn = releasefn

        self._inherited = False
        if signalsafe:
            self._maybedelayedinterrupt = _delayedinterrupt
        else:
            self._maybedelayedinterrupt = util.nullcontextmanager
        self.postrelease = []
        self.pid = self._getpid()
        if dolock:
            self.delay = self.lock()
            if self.acquirefn:
                self.acquirefn()

    def __exit__(self, exc_type, exc_value, exc_tb):
        self.release()

    def __del__(self):
        if self.held:
            warnings.warn(
                r"use lock.release instead of del lock",
                category=DeprecationWarning,
                stacklevel=2,
            )

            # ensure the lock will be removed
            # even if recursive locking did occur
            self.held = 1

                if timeout != 0:
                    time.sleep(1)
                    if timeout > 0:
                        timeout -= 1
                    continue
                raise error.LockHeld(
                    errno.ETIMEDOUT, inst.filename, self.desc, inst.locker
                )

    def _trylock(self):
        if self.held:
            self.held += 1
            return

                        self._parentheld = True
                        self.held = 1
                        return
                    locker = self._testlock(locker)
                    if locker is not None:
                        raise error.LockHeld(
                            errno.EAGAIN,
                            self.vfs.join(self.f),
                            self.desc,
                            locker,
                        )
                else:
                    raise error.LockUnavailable(
                        why.errno, why.strerror, why.filename, self.desc
                    )

        if not self.held:
            # use empty locker to mean "busy for frequent lock/unlock
            # by many processes"
            raise error.LockHeld(
                errno.EAGAIN, self.vfs.join(self.f), self.desc, ""
            )

    def _readlock(self):
        """read lock and return its value

        Returns None if no lock exists, pid for old-style locks, and host:pid

        Communicating this string to the subprocess needs to be done separately
        -- typically by an environment variable.
        """
        if not self.held:
            raise error.LockInheritanceContractViolation(
                'inherit can only be called while lock is held'
            )
        if self._inherited:
            raise error.LockInheritanceContractViolation(
                'inherit cannot be called while lock is already inherited'
            )
        if self._inheritchecker is not None:
            self._inheritchecker()
        if self.releasefn:
            self.releasefn()
        if self._parentheld:

                for callback in self.postrelease:
                    callback()
                # Prevent double usage and help clear cycles.
                self.postrelease = None


def release(*locks):
    for lock in locks:
        if lock is not None:
            lock.release()