This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1603

infinitepush: extract getsrcrepo to a utility module
ClosedPublic

Authored by mbthomas on Dec 6 2017, 6:52 AM.
Tags
None
Subscribers
None

Details

Reviewers
stash
Group Reviewers
Restricted Project
Commits
rFBHGXb7768822f769: infinitepush: extract getsrcrepo to a utility module
Summary

Infinitepush has a function in backupcommands.py for accessing the srcrepo of
shared repos. This is useful in other extensions, so extract it to a utility
module.

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

mbthomas created this revision.Dec 6 2017, 6:52 AM
Herald added a reviewer: Restricted Project. · View Herald TranscriptDec 6 2017, 6:52 AM
stash accepted this revision.Dec 15 2017, 9:12 AM
This revision is now accepted and ready to land.Dec 15 2017, 9:12 AM
Closed by commit rFBHGXb7768822f769: infinitepush: extract getsrcrepo to a utility module (authored by mbthomas). · Explain WhyDec 15 2017, 2:33 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
AMhgext3rd/shareutil.py (27 lines)
Minfinitepush/backupcommands.py (25 lines)

Diff 4496

hgext3rd/shareutil.py

  • This file was added.
# shareutil.py - useful utility methods for accessing shared repos
#
# Copyright 2017 Facebook, Inc.
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
from mercurial import (
hg,
)
def getsrcrepo(repo):
'''returns main repo in case of shared woking copy
'''
if repo.sharedpath == repo.path:
return repo
# the sharedpath always ends in the .hg; we want the path to the repo
source = repo.vfs.split(repo.sharedpath)[0]
srcurl, branches = hg.parseurl(source)
srcrepo = hg.repository(repo.ui, srcurl)
if srcrepo.local():
return srcrepo
else:
return repo

infinitepush/backupcommands.py

) )
from collections import defaultdict, namedtuple from collections import defaultdict, namedtuple
from mercurial import policy from mercurial import policy
from mercurial.extensions import wrapfunction, unwrapfunction from mercurial.extensions import wrapfunction, unwrapfunction
from mercurial.node import bin, hex, nullrev, short from mercurial.node import bin, hex, nullrev, short
from mercurial.i18n import _ from mercurial.i18n import _
from hgext3rd import shareutil
osutil = policy.importmod(r'osutil') osutil = policy.importmod(r'osutil')
cmdtable = {} cmdtable = {}
command = registrar.command(cmdtable) command = registrar.command(cmdtable)
revsetpredicate = registrar.revsetpredicate() revsetpredicate = registrar.revsetpredicate()
backupbookmarktuple = namedtuple('backupbookmarktuple', backupbookmarktuple = namedtuple('backupbookmarktuple',
['hostname', 'reporoot', 'localbookmark']) ['hostname', 'reporoot', 'localbookmark'])
if opts.get('background'): if opts.get('background'):
_dobackgroundbackup(ui, repo, dest) _dobackgroundbackup(ui, repo, dest)
return 0 return 0
try: try:
# Wait at most 30 seconds, because that's the average backup time # Wait at most 30 seconds, because that's the average backup time
timeout = 30 timeout = 30
srcrepo = _getsrcrepo(repo) srcrepo = shareutil.getsrcrepo(repo)
with lockmod.lock(srcrepo.vfs, _backuplockname, timeout=timeout): with lockmod.lock(srcrepo.vfs, _backuplockname, timeout=timeout):
return _dobackup(ui, repo, dest, **opts) return _dobackup(ui, repo, dest, **opts)
except error.LockHeld as e: except error.LockHeld as e:
if e.errno == errno.ETIMEDOUT: if e.errno == errno.ETIMEDOUT:
ui.warn(_('timeout waiting on backup lock\n')) ui.warn(_('timeout waiting on backup lock\n'))
return 0 return 0
else: else:
raise raise
if timeout: if timeout:
timeout = int(timeout) timeout = int(timeout)
else: else:
timeout = -1 timeout = -1
except ValueError: except ValueError:
raise error.Abort('timeout should be integer') raise error.Abort('timeout should be integer')
try: try:
repo = _getsrcrepo(repo) repo = shareutil.getsrcrepo(repo)
with lockmod.lock(repo.vfs, _backuplockname, timeout=timeout): with lockmod.lock(repo.vfs, _backuplockname, timeout=timeout):
pass pass
except error.LockHeld as e: except error.LockHeld as e:
if e.errno == errno.ETIMEDOUT: if e.errno == errno.ETIMEDOUT:
raise error.Abort(_('timeout while waiting for backup')) raise error.Abort(_('timeout while waiting for backup'))
raise raise
@command('isbackedup', @command('isbackedup',
elif maxheadstobackup == 0: elif maxheadstobackup == 0:
backupheads = [] backupheads = []
return set(backupheads) return set(backupheads)
def _dobackup(ui, repo, dest, **opts): def _dobackup(ui, repo, dest, **opts):
ui.status(_('starting backup %s\n') % time.strftime('%H:%M:%S %d %b %Y %Z')) ui.status(_('starting backup %s\n') % time.strftime('%H:%M:%S %d %b %Y %Z'))
start = time.time() start = time.time()
# to handle multiple working copies correctly # to handle multiple working copies correctly
repo = _getsrcrepo(repo) repo = shareutil.getsrcrepo(repo)
currentbkpgenerationvalue = _readbackupgenerationfile(repo.vfs) currentbkpgenerationvalue = _readbackupgenerationfile(repo.vfs)
newbkpgenerationvalue = ui.configint('infinitepushbackup', newbkpgenerationvalue = ui.configint('infinitepushbackup',
'backupgeneration', 0) 'backupgeneration', 0)
if currentbkpgenerationvalue != newbkpgenerationvalue: if currentbkpgenerationvalue != newbkpgenerationvalue:
# Unlinking local backup state will trigger re-backuping # Unlinking local backup state will trigger re-backuping
_deletebackupstate(repo) _deletebackupstate(repo)
_writebackupgenerationfile(repo.vfs, newbkpgenerationvalue) _writebackupgenerationfile(repo.vfs, newbkpgenerationvalue)
bkpstate = _readlocalbackupstate(ui, repo) bkpstate = _readlocalbackupstate(ui, repo)
def _localbackupstateexists(repo): def _localbackupstateexists(repo):
return repo.vfs.exists(_backupstatefile) return repo.vfs.exists(_backupstatefile)
def _deletebackupstate(repo): def _deletebackupstate(repo):
return repo.vfs.tryunlink(_backupstatefile) return repo.vfs.tryunlink(_backupstatefile)
def _readlocalbackupstate(ui, repo): def _readlocalbackupstate(ui, repo):
repo = _getsrcrepo(repo) repo = shareutil.getsrcrepo(repo)
if not _localbackupstateexists(repo): if not _localbackupstateexists(repo):
return backupstate() return backupstate()
with repo.vfs(_backupstatefile) as f: with repo.vfs(_backupstatefile) as f:
try: try:
state = json.loads(f.read()) state = json.loads(f.read())
if (not isinstance(state['bookmarks'], dict) or if (not isinstance(state['bookmarks'], dict) or
not isinstance(state['heads'], list)): not isinstance(state['heads'], list)):
'''Returns new dict that contains items from the first dict that are missing '''Returns new dict that contains items from the first dict that are missing
from the second dict. from the second dict.
''' '''
result = {} result = {}
for book, hexnode in first.items(): for book, hexnode in first.items():
if second.get(book) != hexnode: if second.get(book) != hexnode:
result[book] = hexnode result[book] = hexnode
return result return result
def _getsrcrepo(repo):
'''returns main repo in case of shared woking copy
'''
if repo.sharedpath == repo.path:
return repo
# the sharedpath always ends in the .hg; we want the path to the repo
source = repo.vfs.split(repo.sharedpath)[0]
srcurl, branches = hg.parseurl(source)
srcrepo = hg.repository(repo.ui, srcurl)
if srcrepo.local():
return srcrepo
else:
return repo