This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1565

hiddenoverrides: support nonblocking flock
ClosedPublic

Authored by durham on Nov 30 2017, 6:32 PM.
Tags
None
Subscribers
None

Details

Reviewers
quark
Group Reviewers
Restricted Project
Commits
rFBHGX4bc90c1d6854: hiddenoverrides: support nonblocking flock
Summary

We want to use this flock function in another place, so let's support non
blocking waits. We also want it to throw the appropriate LockHeld in that
situation so the behavior is consistent with a normal Mercurial lock.

Diff Detail

Repository
rFBHGX Facebook Mercurial Extensions
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durham created this revision.Nov 30 2017, 6:32 PM
Herald added a reviewer: Restricted Project. · View Herald TranscriptNov 30 2017, 6:32 PM
quark accepted this revision.Nov 30 2017, 6:38 PM
This revision is now accepted and ready to land.Nov 30 2017, 6:38 PM
Closed by commit rFBHGX4bc90c1d6854: hiddenoverrides: support nonblocking flock (authored by durham). · Explain WhyNov 30 2017, 8:22 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext3rd/fbamend/hiddenoverride.py (34 lines)

Diff 4029

hgext3rd/fbamend/hiddenoverride.py

# hiddenoverride.py - lightweight hidden-ness override # hiddenoverride.py - lightweight hidden-ness override
# #
# Copyright 2017 Facebook, Inc. # Copyright 2017 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import errno
import os import os
import time
from mercurial.node import short from mercurial.node import short
from mercurial import ( from mercurial import (
dispatch, dispatch,
error, error,
extensions, extensions,
lock as lockmod, lock as lockmod,
obsolete, obsolete,
result.add(wnode) result.add(wnode)
except Exception: except Exception:
pass pass
# bookmarks # bookmarks
result.update(repo.unfiltered()._bookmarks.values()) result.update(repo.unfiltered()._bookmarks.values())
return result return result
@contextlib.contextmanager @contextlib.contextmanager
def flock(lockpath): def flock(lockpath, description, timeout=-1):
"""A flock based lock object. Currently it is always non-blocking.
Note that since it is flock based, you can accidentally take it multiple
times within one process and the first one to be released will release all
of them. So the caller needs to be careful to not create more than one
instance per lock.
"""
# best effort lightweight lock # best effort lightweight lock
try: try:
import fcntl import fcntl
fcntl.flock fcntl.flock
except ImportError: except ImportError:
# fallback to Mercurial lock # fallback to Mercurial lock
vfs = vfsmod.vfs(os.path.dirname(lockpath)) vfs = vfsmod.vfs(os.path.dirname(lockpath))
with lockmod.lock(vfs, os.path.basename(lockpath)): with lockmod.lock(vfs, os.path.basename(lockpath), timeout=timeout):
yield yield
return return
# make sure lock file exists # make sure lock file exists
util.makedirs(os.path.dirname(lockpath)) util.makedirs(os.path.dirname(lockpath))
with open(lockpath, 'a'): with open(lockpath, 'a'):
pass pass
lockfd = os.open(lockpath, os.O_RDONLY | os.O_CREAT, 0o664) lockfd = os.open(lockpath, os.O_RDONLY, 0o664)
fcntl.flock(lockfd, fcntl.LOCK_EX) start = time.time()
while True:
try:
fcntl.flock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB)
break
except IOError as ex:
if ex.errno == errno.EAGAIN:
if timeout != -1 and time.time() - start > timeout:
raise error.LockHeld(errno.EAGAIN, lockpath, description,
'')
else:
time.sleep(0.05)
continue
raise
try: try:
yield yield
finally: finally:
fcntl.flock(lockfd, fcntl.LOCK_UN) fcntl.flock(lockfd, fcntl.LOCK_UN)
os.close(lockfd) os.close(lockfd)
def savepinnednodes(repo, newpin, newunpin, fullargs): def savepinnednodes(repo, newpin, newunpin, fullargs):
# take a narrowed lock so it does not affect repo lock # take a narrowed lock so it does not affect repo lock
with flock(repo.svfs.join('obsinhibit.lock')): with flock(repo.svfs.join('obsinhibit.lock'), 'save pinned nodes'):
orignodes = loadpinnednodes(repo) orignodes = loadpinnednodes(repo)
nodes = set(orignodes) nodes = set(orignodes)
nodes |= set(newpin) nodes |= set(newpin)
nodes -= set(newunpin) nodes -= set(newunpin)
with util.atomictempfile(repo.svfs.join('obsinhibit')) as f: with util.atomictempfile(repo.svfs.join('obsinhibit')) as f:
f.write(''.join(nodes)) f.write(''.join(nodes))
desc = lambda s: [short(n) for n in s] desc = lambda s: [short(n) for n in s]