| quark |
| Restricted Project |
The flock function supports windows and is cleaner. Let's delete the fcntllock
class and migrate consumers to the flock function.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext3rd/extutil.py (41 lines) | |||
| M | remotefilelog/debugcommands.py (10 lines) | |||
| M | remotefilelog/repack.py (6 lines) | |||
| M | tests/test-extutil.py (8 lines) |
| # 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 contextlib | ||||
| import errno | import errno | ||||
| import fcntl | |||||
| import os | import os | ||||
| import subprocess | import subprocess | ||||
| import time | import time | ||||
| from mercurial.i18n import _ | |||||
| from mercurial import ( | from mercurial import ( | ||||
| error, | error, | ||||
| lock as lockmod, | lock as lockmod, | ||||
| pycompat, | pycompat, | ||||
| util, | util, | ||||
| vfs as vfsmod, | vfs as vfsmod, | ||||
| ) | ) | ||||
| for oldbase in subcls.__bases__ | for oldbase in subcls.__bases__ | ||||
| if oldbase != oldcls] | if oldbase != oldcls] | ||||
| newbases.append(cls) | newbases.append(cls) | ||||
| subcls.__bases__ = tuple(newbases) | subcls.__bases__ = tuple(newbases) | ||||
| setattr(container, classname, cls) | setattr(container, classname, cls) | ||||
| return cls | return cls | ||||
| return wrap | return wrap | ||||
| class fcntllock(object): | |||||
| """A fcntllock based lock object. Currently it is always non-blocking. | |||||
| Note that since it is fcntllock 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. | |||||
| """ | |||||
| def __init__(self, opener, name, description): | |||||
| self.path = opener.join(name) | |||||
| self.description = description | |||||
| self.fp = None | |||||
| def __enter__(self): | |||||
| path = self.path | |||||
| if self.fp is not None: | |||||
| raise error.Abort(_("unable to re-enter lock '%s'") % path) | |||||
| try: | |||||
| self.fp = open(path, 'w+') | |||||
| except (IOError, OSError) as ex: | |||||
| raise error.Abort(_("unable to create lock file '%s': %s") % | |||||
| (path, str(ex))) | |||||
| try: | |||||
| fcntl.lockf(self.fp, fcntl.LOCK_EX | fcntl.LOCK_NB) | |||||
| except IOError: | |||||
| self.fp.close() | |||||
| self.fp = None | |||||
| raise error.LockHeld(errno.EAGAIN, path, self.description, '') | |||||
| return self | |||||
| def __exit__(self, type, value, traceback): | |||||
| fp = self.fp | |||||
| if fp is not None: | |||||
| fcntl.lockf(fp, fcntl.LOCK_UN) | |||||
| fp.close() | |||||
| self.fp = None | |||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def flock(lockpath, description, timeout=-1): | def flock(lockpath, description, timeout=-1): | ||||
| """A fcntllock based lock object. Currently it is always non-blocking. | """A fcntllock based lock object. Currently it is always non-blocking. | ||||
| Note that since it is fcntllock based, you can accidentally take it multiple | Note that since it is fcntllock based, you can accidentally take it multiple | ||||
| times within one process and the first one to be released will release all | 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 | of them. So the caller needs to be careful to not create more than one | ||||
| instance per lock. | instance per lock. | ||||
| datapack, | datapack, | ||||
| fileserverclient, | fileserverclient, | ||||
| historypack, | historypack, | ||||
| shallowrepo, | shallowrepo, | ||||
| shallowutil, | shallowutil, | ||||
| ) | ) | ||||
| from .repack import repacklockvfs | from .repack import repacklockvfs | ||||
| from .lz4wrapper import lz4decompress | from .lz4wrapper import lz4decompress | ||||
| import hashlib, os, time | import hashlib, os | ||||
| def debugremotefilelog(ui, path, **opts): | def debugremotefilelog(ui, path, **opts): | ||||
| decompress = opts.get('decompress') | decompress = opts.get('decompress') | ||||
| size, firstnode, mapping = parsefileblob(path, decompress) | size, firstnode, mapping = parsefileblob(path, decompress) | ||||
| ui.status(_("size: %s bytes\n") % (size)) | ui.status(_("size: %s bytes\n") % (size)) | ||||
| ui.status(_("path: %s \n") % (path)) | ui.status(_("path: %s \n") % (path)) | ||||
| "P2 Node".ljust(14), | "P2 Node".ljust(14), | ||||
| "Link Node".ljust(14), | "Link Node".ljust(14), | ||||
| "Copy From")) | "Copy From")) | ||||
| lastfilename = filename | lastfilename = filename | ||||
| ui.write("%s %s %s %s %s\n" % (short(node), short(p1node), | ui.write("%s %s %s %s %s\n" % (short(node), short(p1node), | ||||
| short(p2node), short(linknode), copyfrom)) | short(p2node), short(linknode), copyfrom)) | ||||
| def debugwaitonrepack(repo): | def debugwaitonrepack(repo): | ||||
| while True: | with extutil.flock(repacklockvfs(repo).join('repacklock'), ''): | ||||
| try: | |||||
| with extutil.fcntllock(repacklockvfs(repo), 'repacklock', ''): | |||||
| return | return | ||||
| except error.LockHeld: | |||||
| time.sleep(0.1) | |||||
| def debugwaitonprefetch(repo): | def debugwaitonprefetch(repo): | ||||
| with repo._lock(repo.svfs, "prefetchlock", True, None, | with repo._lock(repo.svfs, "prefetchlock", True, None, | ||||
| None, _('prefetching in %s') % repo.origroot): | None, _('prefetching in %s') % repo.origroot): | ||||
| pass | pass | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| from hgext3rd.extutil import runshellcommand, fcntllock | from hgext3rd.extutil import runshellcommand, flock | ||||
| from mercurial import ( | from mercurial import ( | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| mdiff, | mdiff, | ||||
| policy, | policy, | ||||
| scmutil, | scmutil, | ||||
| util, | util, | ||||
| vfs, | vfs, | ||||
| raise ValueError("Function 'isold' is not properly specified") | raise ValueError("Function 'isold' is not properly specified") | ||||
| # use (filename, node) tuple as a keepset key | # use (filename, node) tuple as a keepset key | ||||
| self.keepkeys = keepset(repo, lambda f, n : (f, n)) | self.keepkeys = keepset(repo, lambda f, n : (f, n)) | ||||
| self.isold = isold | self.isold = isold | ||||
| def run(self, targetdata, targethistory): | def run(self, targetdata, targethistory): | ||||
| ledger = repackledger() | ledger = repackledger() | ||||
| with fcntllock(repacklockvfs(self.repo), "repacklock", | with flock(repacklockvfs(self.repo).join("repacklock"), | ||||
| _('repacking %s') % self.repo.origroot): | _('repacking %s') % self.repo.origroot, timeout=0): | ||||
| self.repo.hook('prerepack') | self.repo.hook('prerepack') | ||||
| # Populate ledger from source | # Populate ledger from source | ||||
| self.data.markledger(ledger, options=self.options) | self.data.markledger(ledger, options=self.options) | ||||
| self.history.markledger(ledger, options=self.options) | self.history.markledger(ledger, options=self.options) | ||||
| # Run repack | # Run repack | ||||
| self.repackdata(ledger, targetdata) | self.repackdata(ledger, targetdata) | ||||
| '''runbgcommand() should throw if executing the process fails.''' | '''runbgcommand() should throw if executing the process fails.''' | ||||
| env = os.environ.copy() | env = os.environ.copy() | ||||
| try: | try: | ||||
| extutil.runbgcommand([os.devnull, 'arg1', 'arg2'], env) | extutil.runbgcommand([os.devnull, 'arg1', 'arg2'], env) | ||||
| self.fail('expected runbgcommand to fail with EACCES') | self.fail('expected runbgcommand to fail with EACCES') | ||||
| except OSError as ex: | except OSError as ex: | ||||
| self.assertEqual(ex.errno, errno.EACCES) | self.assertEqual(ex.errno, errno.EACCES) | ||||
| def testfcntllock(self): | def testflock(self): | ||||
| testtmp = os.environ["TESTTMP"] | testtmp = os.environ["TESTTMP"] | ||||
| opener = vfs.vfs(testtmp) | opener = vfs.vfs(testtmp) | ||||
| name = 'testlock' | name = 'testlock' | ||||
| with extutil.fcntllock(opener, name, 'testing a lock'): | with extutil.flock(opener.join(name), 'testing a lock', | ||||
| timeout=0): | |||||
| otherlock = self.otherprocesslock(opener, name) | otherlock = self.otherprocesslock(opener, name) | ||||
| self.assertEquals(otherlock, locktimeout, | self.assertEquals(otherlock, locktimeout, | ||||
| "other process should not have taken the lock") | "other process should not have taken the lock") | ||||
| otherlock = self.otherprocesslock(opener, name) | otherlock = self.otherprocesslock(opener, name) | ||||
| self.assertEquals(otherlock, locksuccess, | self.assertEquals(otherlock, locksuccess, | ||||
| "other process should have taken the lock") | "other process should have taken the lock") | ||||
| def otherprocesslock(self, opener, name): | def otherprocesslock(self, opener, name): | ||||
| pid = os.fork() | pid = os.fork() | ||||
| if pid == 0: | if pid == 0: | ||||
| try: | try: | ||||
| with extutil.fcntllock(opener, name, 'other process lock'): | with extutil.flock(opener.join(name), 'other process lock', | ||||
| timeout=0): | |||||
| os._exit(locksuccess) | os._exit(locksuccess) | ||||
| except error.LockHeld: | except error.LockHeld: | ||||
| os._exit(locktimeout) | os._exit(locktimeout) | ||||
| else: | else: | ||||
| p, st = os.waitpid(pid, 0) | p, st = os.waitpid(pid, 0) | ||||
| st = worker._exitstatus(st) # Convert back to an int | st = worker._exitstatus(st) # Convert back to an int | ||||
| return st | return st | ||||
| if __name__ == '__main__': | if __name__ == '__main__': | ||||
| silenttestrunner.main(__name__) | silenttestrunner.main(__name__) | ||||