This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1566

extutil: move flock to extutil
ClosedPublic

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

Details

Reviewers
quark
Group Reviewers
Restricted Project
Commits
rFBHGX0eb3df0e50c0: extutil: move flock to extutil
Summary

We want to use this from multiple extensions so let's move it.

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 added a subscriber: quark.Nov 30 2017, 6:38 PM
quark added inline comments.
hgext3rd/extutil.py
206

This is using flock() instead of fcntl() libc function/syscall (the Python module name "fcntl" is just confusing - flock() has nothing to do with fcntl). The comment needs to be updated to use flock.

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 rFBHGX0eb3df0e50c0: extutil: move flock to extutil (authored by durham). · Explain WhyNov 30 2017, 8:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext3rd/extutil.py (52 lines)
Mhgext3rd/fbamend/hiddenoverride.py (55 lines)

Diff 4030

hgext3rd/extutil.py

# extutil.py - useful utility methods for extensions # extutil.py - useful utility methods for extensions
# #
# Copyright 2016 Facebook # Copyright 2016 Facebook
# #
# 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 errno import errno
import fcntl import fcntl
import os import os
import subprocess import subprocess
import time
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
error, error,
lock as lockmod,
pycompat, pycompat,
util,
vfs as vfsmod,
) )
if pycompat.iswindows: if pycompat.iswindows:
# no fork on Windows, but we can create a detached process # no fork on Windows, but we can create a detached process
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863.aspx # https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863.aspx
# No stdlib constant exists for this value # No stdlib constant exists for this value
DETACHED_PROCESS = 0x00000008 DETACHED_PROCESS = 0x00000008
_creationflags = DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP _creationflags = DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
return self return self
def __exit__(self, type, value, traceback): def __exit__(self, type, value, traceback):
fp = self.fp fp = self.fp
if fp is not None: if fp is not None:
fcntl.lockf(fp, fcntl.LOCK_UN) fcntl.lockf(fp, fcntl.LOCK_UN)
fp.close() fp.close()
self.fp = None self.fp = None
@contextlib.contextmanager
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
try:
import fcntl
fcntl.flock
except ImportError:
# fallback to Mercurial lock
vfs = vfsmod.vfs(os.path.dirname(lockpath))
with lockmod.lock(vfs, os.path.basename(lockpath), timeout=timeout):
yield
return
# make sure lock file exists
util.makedirs(os.path.dirname(lockpath))
with open(lockpath, 'a'):
pass
lockfd = os.open(lockpath, os.O_RDONLY, 0o664)
start = time.time()
while True:
try:
fcntl.flock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB)
quarkUnsubmitted
Not Done

This is using flock() instead of fcntl() libc function/syscall (the Python module name "fcntl" is just confusing - flock() has nothing to do with fcntl). The comment needs to be updated to use flock.

quark: This is using `flock()` instead of `fcntl()` libc function/syscall (the Python module name…
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:
yield
finally:
fcntl.flock(lockfd, fcntl.LOCK_UN)
os.close(lockfd)

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 from hgext3rd import extutil
import errno
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,
obsolete, obsolete,
repoview, repoview,
scmutil, scmutil,
util, util,
vfs as vfsmod,
) )
def uisetup(ui): def uisetup(ui):
extensions.wrapfunction(repoview, 'pinnedrevs', pinnedrevs) extensions.wrapfunction(repoview, 'pinnedrevs', pinnedrevs)
extensions.wrapfunction(dispatch, 'runcommand', runcommand) extensions.wrapfunction(dispatch, 'runcommand', runcommand)
extensions.wrapfunction(obsolete, 'createmarkers', createmarkers) extensions.wrapfunction(obsolete, 'createmarkers', createmarkers)
extensions.wrapfunction(scmutil, 'cleanupnodes', cleanupnodes) extensions.wrapfunction(scmutil, 'cleanupnodes', cleanupnodes)
wnode = repo.vfs('dirstate').read(20) wnode = repo.vfs('dirstate').read(20)
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
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
try:
import fcntl
fcntl.flock
except ImportError:
# fallback to Mercurial lock
vfs = vfsmod.vfs(os.path.dirname(lockpath))
with lockmod.lock(vfs, os.path.basename(lockpath), timeout=timeout):
yield
return
# make sure lock file exists
util.makedirs(os.path.dirname(lockpath))
with open(lockpath, 'a'):
pass
lockfd = os.open(lockpath, os.O_RDONLY, 0o664)
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:
yield
finally:
fcntl.flock(lockfd, fcntl.LOCK_UN)
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'), 'save pinned nodes'): with extutil.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]