This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6387

bookmarks: keep bookmarks in .hg/store if new config set
ClosedPublic

Authored by martinvonz on May 16 2019, 2:28 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG526750cdd02d: bookmarks: keep bookmarks in .hg/store if new config set
Summary

Bookmarks storage consists of two parts: (1) the set of bookmarks and
their positions, and (2) the current bookmark. The former can get
updated by exchange, while the latter cannot. However, they are both
stored in directly .hg/ and protected by repo.wlock(). As a result,
ugly workarounds were needed. This patch introduces a new config
option to store the set of bookmarks and their positions in .hg/store/
but still storing the current bookmark directory in .hg/. The config
option only takes effect at repo creation time. It results in a new
requirement being set.

Diff Detail

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

Event Timeline

martinvonz created this revision.May 16 2019, 2:28 AM
Closed by commit rHG526750cdd02d: bookmarks: keep bookmarks in .hg/store if new config set (authored by martinvonz). · Explain WhyMay 17 2019, 9:44 AM
This revision was automatically updated to reflect the committed changes.
indygreg added a subscriber: indygreg.May 17 2019, 11:43 PM

I still need to look at this commit in detail, but any commit that alters the on-disk or on-network behavior of Mercurial should ideally be accompanied by a docs change to mercurial/help/internals. I say ideally because some things still aren't documented. But repo requirements are. Please follow up with a patch to document the new requirement in mercurial/help/internals/requirements.txt.

FWIW thank you for doing this. Bookmarks are logically part of the store and it has bothered me for some time that the file wasn't in .hg/store.

Revision Contents
Changeset List

Diff 15166

hgext/share.py

def extsetup(ui): def extsetup(ui):
extensions.wrapfunction(bookmarks, '_getbkfile', getbkfile) extensions.wrapfunction(bookmarks, '_getbkfile', getbkfile)
extensions.wrapfunction(bookmarks.bmstore, '_recordchange', recordchange) extensions.wrapfunction(bookmarks.bmstore, '_recordchange', recordchange)
extensions.wrapfunction(bookmarks.bmstore, '_writerepo', writerepo) extensions.wrapfunction(bookmarks.bmstore, '_writerepo', writerepo)
extensions.wrapcommand(commands.table, 'clone', clone) extensions.wrapcommand(commands.table, 'clone', clone)
def _hassharedbookmarks(repo): def _hassharedbookmarks(repo):
"""Returns whether this repo has shared bookmarks""" """Returns whether this repo has shared bookmarks"""
if bookmarks.bookmarksinstore(repo):
# Kind of a lie, but it means that we skip our custom reads and writes
# from/to the source repo.
return False
try: try:
shared = repo.vfs.read('shared').splitlines() shared = repo.vfs.read('shared').splitlines()
except IOError as inst: except IOError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
return False return False
return hg.sharedbookmarks in shared return hg.sharedbookmarks in shared

mercurial/bookmarks.py

) )
# label constants # label constants
# until 3.5, bookmarks.current was the advertised name, not # until 3.5, bookmarks.current was the advertised name, not
# bookmarks.active, so we must use both to avoid breaking old # bookmarks.active, so we must use both to avoid breaking old
# custom styles # custom styles
activebookmarklabel = 'bookmarks.active bookmarks.current' activebookmarklabel = 'bookmarks.active bookmarks.current'
BOOKMARKS_IN_STORE_REQUIREMENT = 'bookmarksinstore'
def bookmarksinstore(repo):
return BOOKMARKS_IN_STORE_REQUIREMENT in repo.requirements
def bookmarksvfs(repo):
return repo.svfs if bookmarksinstore(repo) else repo.vfs
def _getbkfile(repo): def _getbkfile(repo):
"""Hook so that extensions that mess with the store can hook bm storage. """Hook so that extensions that mess with the store can hook bm storage.
For core, this just handles wether we should see pending For core, this just handles wether we should see pending
bookmarks or the committed ones. Other extensions (like share) bookmarks or the committed ones. Other extensions (like share)
may need to tweak this behavior further. may need to tweak this behavior further.
""" """
fp, pending = txnutil.trypending(repo.root, repo.vfs, 'bookmarks') fp, pending = txnutil.trypending(repo.root, bookmarksvfs(repo), 'bookmarks')
return fp return fp
class bmstore(object): class bmstore(object):
r"""Storage for bookmarks. r"""Storage for bookmarks.
This object should do all bookmark-related reads and writes, so This object should do all bookmark-related reads and writes, so
that it's fairly simple to replace the storage underlying that it's fairly simple to replace the storage underlying
bookmarks without having to clone the logic surrounding bookmarks without having to clone the logic surrounding
# bookmarks weren't sorted before 4.5 # bookmarks weren't sorted before 4.5
nrefs.sort() nrefs.sort()
except (TypeError, ValueError): except (TypeError, ValueError):
# TypeError: # TypeError:
# - bin(...) # - bin(...)
# ValueError: # ValueError:
# - node in nm, for non-20-bytes entry # - node in nm, for non-20-bytes entry
# - split(...), for string without ' ' # - split(...), for string without ' '
repo.ui.warn(_('malformed line in .hg/bookmarks: %r\n') bookmarkspath = '.hg/bookmarks'
% pycompat.bytestr(line)) if bookmarksinstore(repo):
bookmarkspath = '.hg/store/bookmarks'
repo.ui.warn(_('malformed line in %s: %r\n')
% (bookmarkspath, pycompat.bytestr(line)))
except IOError as inst: except IOError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
self._active = _readactive(repo, self) self._active = _readactive(repo, self)
@property @property
def active(self): def active(self):
return self._active return self._active
old = previous[0] old = previous[0]
bmchanges[name] = (old, node) bmchanges[name] = (old, node)
self._recordchange(tr) self._recordchange(tr)
def _recordchange(self, tr): def _recordchange(self, tr):
"""record that bookmarks have been changed in a transaction """record that bookmarks have been changed in a transaction
The transaction is then responsible for updating the file content.""" The transaction is then responsible for updating the file content."""
location = '' if bookmarksinstore(self._repo) else 'plain'
tr.addfilegenerator('bookmarks', ('bookmarks',), self._write, tr.addfilegenerator('bookmarks', ('bookmarks',), self._write,
location='plain') location=location)
tr.hookargs['bookmark_moved'] = '1' tr.hookargs['bookmark_moved'] = '1'
def _writerepo(self, repo): def _writerepo(self, repo):
"""Factored out for extensibility""" """Factored out for extensibility"""
rbm = repo._bookmarks rbm = repo._bookmarks
if rbm.active not in self._refmap: if rbm.active not in self._refmap:
rbm.active = None rbm.active = None
rbm._writeactive() rbm._writeactive()
with repo.wlock(): if bookmarksinstore(repo):
with repo.vfs('bookmarks', 'w', atomictemp=True, vfs = repo.svfs
checkambig=True) as f: lock = repo.lock()
else:
vfs = repo.vfs
lock = repo.wlock()
with lock:
with vfs('bookmarks', 'w', atomictemp=True, checkambig=True) as f:
self._write(f) self._write(f)
def _writeactive(self): def _writeactive(self):
if self._aclean: if self._aclean:
return return
with self._repo.wlock(): with self._repo.wlock():
if self._active is not None: if self._active is not None:
with self._repo.vfs('bookmarks.current', 'w', atomictemp=True, with self._repo.vfs('bookmarks.current', 'w', atomictemp=True,
def listbookmarks(repo): def listbookmarks(repo):
d = {} d = {}
for book, node in listbinbookmarks(repo): for book, node in listbinbookmarks(repo):
d[book] = hex(node) d[book] = hex(node)
return d return d
def pushbookmark(repo, key, old, new): def pushbookmark(repo, key, old, new):
with repo.wlock(), repo.lock(), repo.transaction('bookmarks') as tr: if bookmarksinstore(repo):
wlock = util.nullcontextmanager()
else:
wlock = repo.wlock()
with wlock, repo.lock(), repo.transaction('bookmarks') as tr:
marks = repo._bookmarks marks = repo._bookmarks
existing = hex(marks.get(key, '')) existing = hex(marks.get(key, ''))
if existing != old and existing != new: if existing != old and existing != new:
return False return False
if new == '': if new == '':
changes = [(key, None)] changes = [(key, None)]
else: else:
if new not in repo: if new not in repo:

mercurial/configitems.py

coreconfigitem('extensions', '.*', coreconfigitem('extensions', '.*',
default=None, default=None,
generic=True, generic=True,
) )
coreconfigitem('extdata', '.*', coreconfigitem('extdata', '.*',
default=None, default=None,
generic=True, generic=True,
) )
coreconfigitem('format', 'bookmarks-in-store',
default=False,
)
coreconfigitem('format', 'chunkcachesize', coreconfigitem('format', 'chunkcachesize',
default=None, default=None,
) )
coreconfigitem('format', 'dotencode', coreconfigitem('format', 'dotencode',
default=True, default=True,
) )
coreconfigitem('format', 'generaldelta', coreconfigitem('format', 'generaldelta',
default=False, default=False,

mercurial/help/config.txt

``revlog-compression`` ``revlog-compression``
Compression algorithm used by revlog. Supported value are `zlib` and `zstd`. Compression algorithm used by revlog. Supported value are `zlib` and `zstd`.
The `zlib` engine is the historical default of Mercurial. `zstd` is a newer The `zlib` engine is the historical default of Mercurial. `zstd` is a newer
format that is usually a net win over `zlib` operating faster at better format that is usually a net win over `zlib` operating faster at better
compression rate. Use `zstd` to reduce CPU usage. compression rate. Use `zstd` to reduce CPU usage.
On some system, Mercurial installation may lack `zstd` supports. Default is `zlib`. On some system, Mercurial installation may lack `zstd` supports. Default is `zlib`.
``bookmarks-in-store``
Store bookmarks in .hg/store/. This means that bookmarks are shared when
using `hg share` regardless of the `-B` option.
Repositories with this on-disk format require Mercurial version 5.1.
Disabled by default.
``graph`` ``graph``
--------- ---------
Web graph view configuration. This section let you change graph Web graph view configuration. This section let you change graph
elements display properties by branches, for instance to make the elements display properties by branches, for instance to make the
``default`` branch stand out. ``default`` branch stand out.
Each line has the following format:: Each line has the following format::

mercurial/localrepo.py

def __init__(self, *paths): def __init__(self, *paths):
super(storecache, self).__init__(*paths) super(storecache, self).__init__(*paths)
for path in paths: for path in paths:
_cachedfiles.add((path, '')) _cachedfiles.add((path, ''))
def join(self, obj, fname): def join(self, obj, fname):
return obj.sjoin(fname) return obj.sjoin(fname)
class mixedrepostorecache(_basefilecache):
"""filecache for a mix files in .hg/store and outside"""
def __init__(self, *pathsandlocations):
# scmutil.filecache only uses the path for passing back into our
# join(), so we can safely pass a list of paths and locations
super(mixedrepostorecache, self).__init__(*pathsandlocations)
for path, location in pathsandlocations:
_cachedfiles.update(pathsandlocations)
def join(self, obj, fnameandlocation):
fname, location = fnameandlocation
if location == '':
return obj.vfs.join(fname)
else:
if location != 'store':
raise error.ProgrammingError('unexpected location: %s' %
location)
return obj.sjoin(fname)
def isfilecached(repo, name): def isfilecached(repo, name):
"""check if a repo has already cached "name" filecache-ed property """check if a repo has already cached "name" filecache-ed property
This returns (cachedobj-or-None, iscached) tuple. This returns (cachedobj-or-None, iscached) tuple.
""" """
cacheentry = repo.unfiltered()._filecache.get(name, None) cacheentry = repo.unfiltered()._filecache.get(name, None)
if not cacheentry: if not cacheentry:
return None, False return None, False
# being successful (repository sizes went up due to worse delta # being successful (repository sizes went up due to worse delta
# chains), and the code was deleted in 4.6. # chains), and the code was deleted in 4.6.
supportedformats = { supportedformats = {
'revlogv1', 'revlogv1',
'generaldelta', 'generaldelta',
'treemanifest', 'treemanifest',
REVLOGV2_REQUIREMENT, REVLOGV2_REQUIREMENT,
SPARSEREVLOG_REQUIREMENT, SPARSEREVLOG_REQUIREMENT,
bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT,
} }
_basesupported = supportedformats | { _basesupported = supportedformats | {
'store', 'store',
'fncache', 'fncache',
'shared', 'shared',
'relshared', 'relshared',
'dotencode', 'dotencode',
'exp-sparse', 'exp-sparse',
In other word, there is always only one level of `repoview` "filtering". In other word, there is always only one level of `repoview` "filtering".
""" """
if self._extrafilterid is not None and '%' not in name: if self._extrafilterid is not None and '%' not in name:
name = name + '%' + self._extrafilterid name = name + '%' + self._extrafilterid
cls = repoview.newtype(self.unfiltered().__class__) cls = repoview.newtype(self.unfiltered().__class__)
return cls(self, name, visibilityexceptions) return cls(self, name, visibilityexceptions)
@repofilecache('bookmarks', 'bookmarks.current') @mixedrepostorecache(('bookmarks', ''), ('bookmarks.current', ''),
('bookmarks', 'store'))
def _bookmarks(self): def _bookmarks(self):
return bookmarks.bmstore(self) return bookmarks.bmstore(self)
@property @property
def _activebookmark(self): def _activebookmark(self):
return self._bookmarks.active return self._bookmarks.active
# _phasesets depend on changelog. what we need is to call # _phasesets depend on changelog. what we need is to call
def _journalfiles(self): def _journalfiles(self):
return ((self.svfs, 'journal'), return ((self.svfs, 'journal'),
(self.svfs, 'journal.narrowspec'), (self.svfs, 'journal.narrowspec'),
(self.vfs, 'journal.narrowspec.dirstate'), (self.vfs, 'journal.narrowspec.dirstate'),
(self.vfs, 'journal.dirstate'), (self.vfs, 'journal.dirstate'),
(self.vfs, 'journal.branch'), (self.vfs, 'journal.branch'),
(self.vfs, 'journal.desc'), (self.vfs, 'journal.desc'),
(self.vfs, 'journal.bookmarks'), (bookmarks.bookmarksvfs(self), 'journal.bookmarks'),
(self.svfs, 'journal.phaseroots')) (self.svfs, 'journal.phaseroots'))
def undofiles(self): def undofiles(self):
return [(vfs, undoname(x)) for vfs, x in self._journalfiles()] return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
@unfilteredmethod @unfilteredmethod
def _writejournal(self, desc): def _writejournal(self, desc):
self.dirstate.savebackup(None, 'journal.dirstate') self.dirstate.savebackup(None, 'journal.dirstate')
narrowspec.savewcbackup(self, 'journal.narrowspec.dirstate') narrowspec.savewcbackup(self, 'journal.narrowspec.dirstate')
narrowspec.savebackup(self, 'journal.narrowspec') narrowspec.savebackup(self, 'journal.narrowspec')
self.vfs.write("journal.branch", self.vfs.write("journal.branch",
encoding.fromlocal(self.dirstate.branch())) encoding.fromlocal(self.dirstate.branch()))
self.vfs.write("journal.desc", self.vfs.write("journal.desc",
"%d\n%s\n" % (len(self), desc)) "%d\n%s\n" % (len(self), desc))
self.vfs.write("journal.bookmarks", bookmarksvfs = bookmarks.bookmarksvfs(self)
self.vfs.tryread("bookmarks")) bookmarksvfs.write("journal.bookmarks",
bookmarksvfs.tryread("bookmarks"))
self.svfs.write("journal.phaseroots", self.svfs.write("journal.phaseroots",
self.svfs.tryread("phaseroots")) self.svfs.tryread("phaseroots"))
def recover(self): def recover(self):
with self.lock(): with self.lock():
if self.svfs.exists("journal"): if self.svfs.exists("journal"):
self.ui.status(_("rolling back interrupted transaction\n")) self.ui.status(_("rolling back interrupted transaction\n"))
vfsmap = {'': self.svfs, vfsmap = {'': self.svfs,
if dryrun: if dryrun:
return 0 return 0
parents = self.dirstate.parents() parents = self.dirstate.parents()
self.destroying() self.destroying()
vfsmap = {'plain': self.vfs, '': self.svfs} vfsmap = {'plain': self.vfs, '': self.svfs}
transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn, transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn,
checkambigfiles=_cachedfiles) checkambigfiles=_cachedfiles)
if self.vfs.exists('undo.bookmarks'): bookmarksvfs = bookmarks.bookmarksvfs(self)
self.vfs.rename('undo.bookmarks', 'bookmarks', checkambig=True) if bookmarksvfs.exists('undo.bookmarks'):
bookmarksvfs.rename('undo.bookmarks', 'bookmarks', checkambig=True)
if self.svfs.exists('undo.phaseroots'): if self.svfs.exists('undo.phaseroots'):
self.svfs.rename('undo.phaseroots', 'phaseroots', checkambig=True) self.svfs.rename('undo.phaseroots', 'phaseroots', checkambig=True)
self.invalidate() self.invalidate()
parentgone = any(p not in self.changelog.nodemap for p in parents) parentgone = any(p not in self.changelog.nodemap for p in parents)
if parentgone: if parentgone:
# prevent dirstateguard from overwriting already restored one # prevent dirstateguard from overwriting already restored one
dsguard.close() dsguard.close()
requirements.add('internal-phase') requirements.add('internal-phase')
if createopts.get('narrowfiles'): if createopts.get('narrowfiles'):
requirements.add(repository.NARROW_REQUIREMENT) requirements.add(repository.NARROW_REQUIREMENT)
if createopts.get('lfs'): if createopts.get('lfs'):
requirements.add('lfs') requirements.add('lfs')
if ui.configbool('format', 'bookmarks-in-store'):
requirements.add(bookmarks.BOOKMARKS_IN_STORE_REQUIREMENT)
return requirements return requirements
def filterknowncreateopts(ui, createopts): def filterknowncreateopts(ui, createopts):
"""Filters a dict of repo creation options against options that are known. """Filters a dict of repo creation options against options that are known.
Receives a dict of repo creation options and returns a dict of those Receives a dict of repo creation options and returns a dict of those
options that we don't know how to handle. options that we don't know how to handle.

mercurial/store.py

mode = vfs.stat().st_mode mode = vfs.stat().st_mode
# avoid some useless chmods # avoid some useless chmods
if (0o777 & ~util.umask) == (0o777 & mode): if (0o777 & ~util.umask) == (0o777 & mode):
mode = None mode = None
except OSError: except OSError:
mode = None mode = None
return mode return mode
_data = ('narrowspec data meta 00manifest.d 00manifest.i' _data = ('bookmarks narrowspec data meta 00manifest.d 00manifest.i'
' 00changelog.d 00changelog.i phaseroots obsstore') ' 00changelog.d 00changelog.i phaseroots obsstore')
def isrevlog(f, kind, st): def isrevlog(f, kind, st):
return kind == stat.S_IFREG and f[-2:] in ('.i', '.d') return kind == stat.S_IFREG and f[-2:] in ('.i', '.d')
class basicstore(object): class basicstore(object):
'''base class for local repository stores''' '''base class for local repository stores'''
def __init__(self, path, vfstype): def __init__(self, path, vfstype):
ef = self.encode(f) ef = self.encode(f)
try: try:
yield f, ef, self.getsize(ef) yield f, ef, self.getsize(ef)
except OSError as err: except OSError as err:
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
def copylist(self): def copylist(self):
d = ('narrowspec data meta dh fncache phaseroots obsstore' d = ('bookmarks narrowspec data meta dh fncache phaseroots obsstore'
' 00manifest.d 00manifest.i 00changelog.d 00changelog.i') ' 00manifest.d 00manifest.i 00changelog.d 00changelog.i')
return (['requires', '00changelog.i'] + return (['requires', '00changelog.i'] +
['store/' + f for f in d.split()]) ['store/' + f for f in d.split()])
def write(self, tr): def write(self, tr):
self.fncache.write(tr) self.fncache.write(tr)
def invalidatecaches(self): def invalidatecaches(self):

tests/test-help.t

"usefncache" "usefncache"
"usestore" "usestore"
"sparse-revlog" "sparse-revlog"
"revlog-compression" "revlog-compression"
"bookmarks-in-store"
"profiling" "profiling"
----------- -----------
"format" "format"
"progress" "progress"
---------- ----------

tests/test-share-bookmarks.t

#testcases vfs svfs
$ echo "[extensions]" >> $HGRCPATH $ echo "[extensions]" >> $HGRCPATH
$ echo "share = " >> $HGRCPATH $ echo "share = " >> $HGRCPATH
#if svfs
$ echo "[format]" >> $HGRCPATH
$ echo "bookmarks-in-store = yes " >> $HGRCPATH
#endif
prepare repo1 prepare repo1
$ hg init repo1 $ hg init repo1
$ cd repo1 $ cd repo1
$ echo a > a $ echo a > a
$ hg commit -A -m'init' $ hg commit -A -m'init'
adding a adding a
$ echo a >> a $ echo a >> a
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd repo1 $ cd repo1
$ hg bookmark bm1 $ hg bookmark bm1
$ hg bookmarks $ hg bookmarks
* bm1 2:c2e0ac586386 * bm1 2:c2e0ac586386
$ cd ../repo2 $ cd ../repo2
$ hg book bm2 $ hg book bm2
$ hg bookmarks $ hg bookmarks
bm1 2:c2e0ac586386 (svfs !)
* bm2 2:c2e0ac586386 * bm2 2:c2e0ac586386
$ cd ../repo3 $ cd ../repo3
$ hg bookmarks $ hg bookmarks
bm1 2:c2e0ac586386 bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
$ hg book bm3 $ hg book bm3
$ hg bookmarks $ hg bookmarks
bm1 2:c2e0ac586386 bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
* bm3 2:c2e0ac586386 * bm3 2:c2e0ac586386
$ cd ../repo1 $ cd ../repo1
$ hg bookmarks $ hg bookmarks
* bm1 2:c2e0ac586386 * bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
bm3 2:c2e0ac586386 bm3 2:c2e0ac586386
check whether HG_PENDING makes pending changes only in relatd check whether HG_PENDING makes pending changes only in relatd
repositories visible to an external hook. repositories visible to an external hook.
In "hg share" case, another transaction can't run in other In "hg share" case, another transaction can't run in other
repositories sharing same source repository, because starting repositories sharing same source repository, because starting
transaction requires locking store of source repository. transaction requires locking store of source repository.
> hg -R "$TESTTMP/repo3" bookmarks > hg -R "$TESTTMP/repo3" bookmarks
> exit 1 # to avoid adding new bookmark for subsequent tests > exit 1 # to avoid adding new bookmark for subsequent tests
> EOF > EOF
$ cd ../repo1 $ cd ../repo1
$ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX $ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX
@repo1 @repo1
bm1 2:c2e0ac586386 bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
bm3 2:c2e0ac586386 bm3 2:c2e0ac586386
* bmX 2:c2e0ac586386 * bmX 2:c2e0ac586386
@repo2 @repo2
bm1 2:c2e0ac586386 (svfs !)
* bm2 2:c2e0ac586386 * bm2 2:c2e0ac586386
bm3 2:c2e0ac586386 (svfs !)
@repo3 @repo3
bm1 2:c2e0ac586386 bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
* bm3 2:c2e0ac586386 * bm3 2:c2e0ac586386
bmX 2:c2e0ac586386 bmX 2:c2e0ac586386 (vfs !)
transaction abort! transaction abort!
rollback completed rollback completed
abort: pretxnclose hook exited with status 1 abort: pretxnclose hook exited with status 1
[255] [255]
$ hg book bm1 $ hg book bm1
FYI, in contrast to above test, bmX is invisible in repo1 (= shared FYI, in contrast to above test, bmX is invisible in repo1 (= shared
src), because (1) HG_PENDING refers only repo3 and (2) src), because (1) HG_PENDING refers only repo3 and (2)
"bookmarks.pending" is written only into repo3. "bookmarks.pending" is written only into repo3.
$ cd ../repo3 $ cd ../repo3
$ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX $ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX
@repo1 @repo1
* bm1 2:c2e0ac586386 * bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
bm3 2:c2e0ac586386 bm3 2:c2e0ac586386
@repo2 @repo2
bm1 2:c2e0ac586386 (svfs !)
* bm2 2:c2e0ac586386 * bm2 2:c2e0ac586386
bm3 2:c2e0ac586386 (svfs !)
@repo3 @repo3
bm1 2:c2e0ac586386 bm1 2:c2e0ac586386
bm2 2:c2e0ac586386 (svfs !)
bm3 2:c2e0ac586386 bm3 2:c2e0ac586386
* bmX 2:c2e0ac586386 * bmX 2:c2e0ac586386
transaction abort! transaction abort!
rollback completed rollback completed
abort: pretxnclose hook exited with status 1 abort: pretxnclose hook exited with status 1
[255] [255]
$ hg book bm3 $ hg book bm3
clean up bm2 since it's uninteresting (not shared in the vfs case and
same as bm3 in the svfs case)
$ cd ../repo2
$ hg book -d bm2
$ cd ../repo1 $ cd ../repo1
test that commits work test that commits work
$ echo 'shared bookmarks' > a $ echo 'shared bookmarks' > a
$ hg commit -m 'testing shared bookmarks' $ hg commit -m 'testing shared bookmarks'
$ hg bookmarks $ hg bookmarks
* bm1 3:b87954705719 * bm1 3:b87954705719