( )⚙ D10315 store: also return some information about the type of file `walk` found

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10315

store: also return some information about the type of file `walk` found
ClosedPublic

Authored by marmoute on Apr 6 2021, 4:39 AM.

Details

Reviewers
durin42
martinvonz
pulkit
Group Reviewers
hg-reviewers
Commits
rHG6085b7f1536d: store: also return some information about the type of file `walk` found
Summary

We start returning of 4th information in the store.walk return tuple: the type of the file. This will make it easier for caller to determine which kind of file they are looking at. This should especically help with the upgrade-repo code that has to do a lot of fragile index's file name comparison.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.Apr 6 2021, 4:39 AM
pulkit added a subscriber: pulkit.Apr 8 2021, 3:04 AM
pulkit added inline comments.
mercurial/store.py
1

hm, unrelated change?

marmoute planned changes to this revision.Apr 8 2021, 6:03 AM
marmoute added inline comments.
mercurial/store.py
1

No! No! I totally intended to add , f), f) at the end of this docstring.

(hum, update coming)

baymax updated this revision to Diff 26701.Apr 8 2021, 7:02 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 26704.Apr 8 2021, 10:09 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

pulkit accepted this revision.Apr 8 2021, 12:52 PM

I have needed this in past. Thanks!

This revision is now accepted and ready to land.Apr 8 2021, 12:52 PM
marmoute updated this revision to Diff 26727.Apr 8 2021, 6:57 PM
baymax updated this revision to Diff 26733.Apr 8 2021, 7:54 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

pulkit accepted this revision.Apr 11 2021, 5:25 PM

Revision Contents
Changeset List

Diff 26701

hgext/largefiles/lfutil.py

def unixpath(path): def unixpath(path):
'''Return a version of path normalized for use with the lfdirstate.''' '''Return a version of path normalized for use with the lfdirstate.'''
return util.pconvert(os.path.normpath(path)) return util.pconvert(os.path.normpath(path))
def islfilesrepo(repo): def islfilesrepo(repo):
'''Return true if the repo is a largefile repo.''' '''Return true if the repo is a largefile repo.'''
if b'largefiles' in repo.requirements and any( if b'largefiles' in repo.requirements and any(
shortnameslash in f[0] for f in repo.store.datafiles() shortnameslash in f[1] for f in repo.store.datafiles()
): ):
return True return True
return any(openlfdirstate(repo.ui, repo, False)) return any(openlfdirstate(repo.ui, repo, False))
class storeprotonotcapable(Exception): class storeprotonotcapable(Exception):
def __init__(self, storetypes): def __init__(self, storetypes):

hgext/largefiles/reposetup.py

addfunc = lambda fn, lfhash: toupload.add(lfhash) addfunc = lambda fn, lfhash: toupload.add(lfhash)
lfutil.getlfilestoupload(pushop.repo, lfrevs, addfunc) lfutil.getlfilestoupload(pushop.repo, lfrevs, addfunc)
lfcommands.uploadlfiles(ui, pushop.repo, pushop.remote, toupload) lfcommands.uploadlfiles(ui, pushop.repo, pushop.remote, toupload)
repo.prepushoutgoinghooks.add(b"largefiles", prepushoutgoinghook) repo.prepushoutgoinghooks.add(b"largefiles", prepushoutgoinghook)
def checkrequireslfiles(ui, repo, **kwargs): def checkrequireslfiles(ui, repo, **kwargs):
if b'largefiles' not in repo.requirements and any( if b'largefiles' not in repo.requirements and any(
lfutil.shortname + b'/' in f[0] for f in repo.store.datafiles() lfutil.shortname + b'/' in f[1] for f in repo.store.datafiles()
): ):
repo.requirements.add(b'largefiles') repo.requirements.add(b'largefiles')
scmutil.writereporequirements(repo) scmutil.writereporequirements(repo)
ui.setconfig( ui.setconfig(
b'hooks', b'changegroup.lfiles', checkrequireslfiles, b'largefiles' b'hooks', b'changegroup.lfiles', checkrequireslfiles, b'largefiles'
) )
ui.setconfig(b'hooks', b'commit.lfiles', checkrequireslfiles, b'largefiles') ui.setconfig(b'hooks', b'commit.lfiles', checkrequireslfiles, b'largefiles')

hgext/narrow/narrowcommands.py

) )
) )
hg.clean(repo, urev) hg.clean(repo, urev)
overrides = {(b'devel', b'strip-obsmarkers'): False} overrides = {(b'devel', b'strip-obsmarkers'): False}
with ui.configoverride(overrides, b'narrow'): with ui.configoverride(overrides, b'narrow'):
repair.strip(ui, unfi, tostrip, topic=b'narrow', backup=backup) repair.strip(ui, unfi, tostrip, topic=b'narrow', backup=backup)
todelete = [] todelete = []
for f, f2, size in repo.store.datafiles(): for t, f, f2, size in repo.store.datafiles():
if f.startswith(b'data/'): if f.startswith(b'data/'):
file = f[5:-2] file = f[5:-2]
if not newmatch(file): if not newmatch(file):
todelete.append(f) todelete.append(f)
elif f.startswith(b'meta/'): elif f.startswith(b'meta/'):
dir = f[5:-13] dir = f[5:-13]
dirs = sorted(pathutil.dirs({dir})) + [dir] dirs = sorted(pathutil.dirs({dir})) + [dir]
include = True include = True

hgext/remotefilelog/contentstore.py

if linkrev < startlinkrev: if linkrev < startlinkrev:
break break
if linkrev > endlinkrev: if linkrev > endlinkrev:
continue continue
node = rl.node(rev) node = rl.node(rev)
ledger.markdataentry(self, treename, node) ledger.markdataentry(self, treename, node)
ledger.markhistoryentry(self, treename, node) ledger.markhistoryentry(self, treename, node)
for path, encoded, size in self._store.datafiles(): for t, path, encoded, size in self._store.datafiles():
if path[:5] != b'meta/' or path[-2:] != b'.i': if path[:5] != b'meta/' or path[-2:] != b'.i':
continue continue
treename = path[5 : -len(b'/00manifest.i')] treename = path[5 : -len(b'/00manifest.i')]
rl = revlog.revlog(self._svfs, path) rl = revlog.revlog(self._svfs, path)
for rev in pycompat.xrange(len(rl) - 1, -1, -1): for rev in pycompat.xrange(len(rl) - 1, -1, -1):
linkrev = rl.linkrev(rev) linkrev = rl.linkrev(rev)

hgext/remotefilelog/remotefilelogserver.py

p = visit.pop() p = visit.pop()
for f, kind, st in readdir(p, stat=True): for f, kind, st in readdir(p, stat=True):
fp = p + b'/' + f fp = p + b'/' + f
if kind == stat.S_IFREG: if kind == stat.S_IFREG:
if not fp.endswith(b'.i') and not fp.endswith( if not fp.endswith(b'.i') and not fp.endswith(
b'.d' b'.d'
): ):
n = util.pconvert(fp[striplen:]) n = util.pconvert(fp[striplen:])
yield (store.decodedir(n), n, st.st_size) d = store.decodedir(n)
t = store.FILETYPE_OTHER
yield (t, d, n, st.st_size)
if kind == stat.S_IFDIR: if kind == stat.S_IFDIR:
visit.append(fp) visit.append(fp)
if scmutil.istreemanifest(repo): if scmutil.istreemanifest(repo):
for (u, e, s) in repo.store.datafiles(): for (t, u, e, s) in repo.store.datafiles():
if u.startswith(b'meta/') and ( if u.startswith(b'meta/') and (
u.endswith(b'.i') or u.endswith(b'.d') u.endswith(b'.i') or u.endswith(b'.d')
): ):
yield (u, e, s) yield (t, u, e, s)
# Return .d and .i files that do not match the shallow pattern # Return .d and .i files that do not match the shallow pattern
match = state.match match = state.match
if match and not match.always(): if match and not match.always():
for (u, e, s) in repo.store.datafiles(): for (t, u, e, s) in repo.store.datafiles():
f = u[5:-2] # trim data/... and .i/.d f = u[5:-2] # trim data/... and .i/.d
if not state.match(f): if not state.match(f):
yield (u, e, s) yield (t, u, e, s)
for x in repo.store.topfiles(): for x in repo.store.topfiles():
if state.noflatmf and x[0][:11] == b'00manifest.': if state.noflatmf and x[0][:11] == b'00manifest.':
continue continue
yield x yield x
elif shallowutil.isenabled(repo): elif shallowutil.isenabled(repo):
# don't allow cloning from a shallow repo to a full repo # don't allow cloning from a shallow repo to a full repo

mercurial/repair.py

revlog.strip(striprev, tr) revlog.strip(striprev, tr)
def manifestrevlogs(repo): def manifestrevlogs(repo):
yield repo.manifestlog.getstorage(b'') yield repo.manifestlog.getstorage(b'')
if scmutil.istreemanifest(repo): if scmutil.istreemanifest(repo):
# This logic is safe if treemanifest isn't enabled, but also # This logic is safe if treemanifest isn't enabled, but also
# pointless, so we skip it if treemanifest isn't enabled. # pointless, so we skip it if treemanifest isn't enabled.
for unencoded, encoded, size in repo.store.datafiles(): for t, unencoded, encoded, size in repo.store.datafiles():
if unencoded.startswith(b'meta/') and unencoded.endswith( if unencoded.startswith(b'meta/') and unencoded.endswith(
b'00manifest.i' b'00manifest.i'
): ):
dir = unencoded[5:-12] dir = unencoded[5:-12]
yield repo.manifestlog.getstorage(dir) yield repo.manifestlog.getstorage(dir)
def rebuildfncache(ui, repo): def rebuildfncache(ui, repo):

mercurial/store.py

# store.py - repository store handling for Mercurial # store.py - repository store handling for Mercurial
pulkitUnsubmitted
Not Done

hm, unrelated change?

pulkit: hm, unrelated change?
marmouteAuthorUnsubmitted
Done

No! No! I totally intended to add , f), f) at the end of this docstring.

(hum, update coming)

marmoute: No! No! I totally intended to add `, f), f)` at the end of this docstring. (hum, update coming)
# #
# Copyright 2008 Olivia Mackall <olivia@selenic.com> # Copyright 2008 Olivia Mackall <olivia@selenic.com>
# #
# 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
b'00manifest.i', b'00manifest.i',
b'00changelog.d', b'00changelog.d',
b'00changelog.i', b'00changelog.i',
b'phaseroots', b'phaseroots',
b'obsstore', b'obsstore',
b'requires', b'requires',
] ]
REVLOG_FILES_EXT = (b'.i', b'.d', b'.n', b'.nd') REVLOG_FILES_MAIN_EXT = (b'.i', b'i.tmpcensored')
REVLOG_FILES_OTHER_EXT = (b'.d', b'.n', b'.nd', b'd.tmpcensored')
def isrevlog(f, kind, st): def is_revlog(f, kind, st):
if kind != stat.S_IFREG: if kind != stat.S_IFREG:
return False return None
return f.endswith(REVLOG_FILES_EXT) return revlog_type(f)
def revlog_type(f):
if f.endswith(REVLOG_FILES_MAIN_EXT):
return FILEFLAGS_REVLOG_MAIN
elif f.endswith(REVLOG_FILES_OTHER_EXT):
return FILETYPE_FILELOG_OTHER
# the file is part of changelog data
FILEFLAGS_CHANGELOG = 1 << 13
# the file is part of manifest data
FILEFLAGS_MANIFESTLOG = 1 << 12
# the file is part of filelog data
FILEFLAGS_FILELOG = 1 << 11
# file that are not directly part of a revlog
FILEFLAGS_OTHER = 1 << 10
# the main entry point for a revlog
FILEFLAGS_REVLOG_MAIN = 1 << 1
# a secondary file for a revlog
FILEFLAGS_REVLOG_OTHER = 1 << 0
FILETYPE_CHANGELOG_MAIN = FILEFLAGS_CHANGELOG | FILEFLAGS_REVLOG_MAIN
FILETYPE_CHANGELOG_OTHER = FILEFLAGS_CHANGELOG | FILEFLAGS_REVLOG_OTHER
FILETYPE_MANIFESTLOG_MAIN = FILEFLAGS_MANIFESTLOG | FILEFLAGS_REVLOG_MAIN
FILETYPE_MANIFESTLOG_OTHER = FILEFLAGS_MANIFESTLOG | FILEFLAGS_REVLOG_OTHER
FILETYPE_FILELOG_MAIN = FILEFLAGS_FILELOG | FILEFLAGS_REVLOG_MAIN
FILETYPE_FILELOG_OTHER = FILEFLAGS_FILELOG | FILEFLAGS_REVLOG_OTHER
FILETYPE_OTHER = FILEFLAGS_OTHER
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):
vfs = vfstype(path) vfs = vfstype(path)
self.path = vfs.base self.path = vfs.base
l = [] l = []
if self.rawvfs.isdir(path): if self.rawvfs.isdir(path):
visit = [path] visit = [path]
readdir = self.rawvfs.readdir readdir = self.rawvfs.readdir
while visit: while visit:
p = visit.pop() p = visit.pop()
for f, kind, st in readdir(p, stat=True): for f, kind, st in readdir(p, stat=True):
fp = p + b'/' + f fp = p + b'/' + f
if isrevlog(f, kind, st): rl_type = is_revlog(f, kind, st)
if rl_type is not None:
n = util.pconvert(fp[striplen:]) n = util.pconvert(fp[striplen:])
l.append((decodedir(n), n, st.st_size)) l.append((rl_type, decodedir(n), n, st.st_size))
elif kind == stat.S_IFDIR and recurse: elif kind == stat.S_IFDIR and recurse:
visit.append(fp) visit.append(fp)
l.sort() l.sort()
return l return l
def changelog(self, trypending, concurrencychecker=None): def changelog(self, trypending, concurrencychecker=None):
return changelog.changelog( return changelog.changelog(
self.vfs, self.vfs,
trypending=trypending, trypending=trypending,
concurrencychecker=concurrencychecker, concurrencychecker=concurrencychecker,
) )
def manifestlog(self, repo, storenarrowmatch): def manifestlog(self, repo, storenarrowmatch):
rootstore = manifest.manifestrevlog(repo.nodeconstants, self.vfs) rootstore = manifest.manifestrevlog(repo.nodeconstants, self.vfs)
return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch) return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch)
def datafiles(self, matcher=None): def datafiles(self, matcher=None):
return self._walk(b'data', True) + self._walk(b'meta', True) files = self._walk(b'data', True) + self._walk(b'meta', True)
for (t, u, e, s) in files:
yield (FILEFLAGS_FILELOG | t, u, e, s)
def topfiles(self): def topfiles(self):
# yield manifest before changelog # yield manifest before changelog
return reversed(self._walk(b'', False)) files = reversed(self._walk(b'', False))
for (t, u, e, s) in files:
if u.startswith(b'00changelog'):
yield (FILEFLAGS_CHANGELOG | t, u, e, s)
elif u.startswith(b'00manifest'):
yield (FILEFLAGS_MANIFESTLOG | t, u, e, s)
else:
yield (FILETYPE_OTHER | t, u, e, s)
def walk(self, matcher=None): def walk(self, matcher=None):
"""return files related to data storage (ie: revlogs) """return files related to data storage (ie: revlogs)
yields (unencoded, encoded, size) yields (file_type, unencoded, encoded, size)
if a matcher is passed, storage files of only those tracked paths if a matcher is passed, storage files of only those tracked paths
are passed with matches the matcher are passed with matches the matcher
""" """
# yield data files first # yield data files first
for x in self.datafiles(matcher): for x in self.datafiles(matcher):
yield x yield x
for x in self.topfiles(): for x in self.topfiles():
self.path = vfs.base self.path = vfs.base
self.createmode = _calcmode(vfs) self.createmode = _calcmode(vfs)
vfs.createmode = self.createmode vfs.createmode = self.createmode
self.rawvfs = vfs self.rawvfs = vfs
self.vfs = vfsmod.filtervfs(vfs, encodefilename) self.vfs = vfsmod.filtervfs(vfs, encodefilename)
self.opener = self.vfs self.opener = self.vfs
def datafiles(self, matcher=None): def datafiles(self, matcher=None):
for a, b, size in super(encodedstore, self).datafiles(): for t, a, b, size in super(encodedstore, self).datafiles():
try: try:
a = decodefilename(a) a = decodefilename(a)
except KeyError: except KeyError:
a = None a = None
if a is not None and not _matchtrackedpath(a, matcher): if a is not None and not _matchtrackedpath(a, matcher):
continue continue
yield a, b, size yield t, a, b, size
def join(self, f): def join(self, f):
return self.path + b'/' + encodefilename(f) return self.path + b'/' + encodefilename(f)
def copylist(self): def copylist(self):
return [b'requires', b'00changelog.i'] + [b'store/' + f for f in _data] return [b'requires', b'00changelog.i'] + [b'store/' + f for f in _data]
return self.rawvfs.stat(path).st_size return self.rawvfs.stat(path).st_size
def datafiles(self, matcher=None): def datafiles(self, matcher=None):
for f in sorted(self.fncache): for f in sorted(self.fncache):
if not _matchtrackedpath(f, matcher): if not _matchtrackedpath(f, matcher):
continue continue
ef = self.encode(f) ef = self.encode(f)
try: try:
yield f, ef, self.getsize(ef) t = revlog_type(f)
t |= FILEFLAGS_FILELOG
yield t, 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 = ( d = (
b'bookmarks', b'bookmarks',
b'narrowspec', b'narrowspec',

mercurial/streamclone.py

This function will obtain a repository lock to ensure a consistent view of This function will obtain a repository lock to ensure a consistent view of
the store is captured. It therefore may raise LockError. the store is captured. It therefore may raise LockError.
""" """
entries = [] entries = []
total_bytes = 0 total_bytes = 0
# Get consistent snapshot of repo, lock during scan. # Get consistent snapshot of repo, lock during scan.
with repo.lock(): with repo.lock():
repo.ui.debug(b'scanning\n') repo.ui.debug(b'scanning\n')
for name, ename, size in _walkstreamfiles(repo): for file_type, name, ename, size in _walkstreamfiles(repo):
if size: if size:
entries.append((name, size)) entries.append((name, size))
total_bytes += size total_bytes += size
repo.ui.debug( repo.ui.debug(
b'%d files, %d bytes to transfer\n' % (len(entries), total_bytes) b'%d files, %d bytes to transfer\n' % (len(entries), total_bytes)
) )
entries = [] entries = []
totalfilesize = 0 totalfilesize = 0
matcher = None matcher = None
if includes or excludes: if includes or excludes:
matcher = narrowspec.match(repo.root, includes, excludes) matcher = narrowspec.match(repo.root, includes, excludes)
repo.ui.debug(b'scanning\n') repo.ui.debug(b'scanning\n')
for name, ename, size in _walkstreamfiles(repo, matcher): for rl_type, name, ename, size in _walkstreamfiles(repo, matcher):
if size: if size:
entries.append((_srcstore, name, _fileappend, size)) entries.append((_srcstore, name, _fileappend, size))
totalfilesize += size totalfilesize += size
for name in _walkstreamfullstorefiles(repo): for name in _walkstreamfullstorefiles(repo):
if repo.svfs.exists(name): if repo.svfs.exists(name):
totalfilesize += repo.svfs.lstat(name).st_size totalfilesize += repo.svfs.lstat(name).st_size
entries.append((_srcstore, name, _filefull, None)) entries.append((_srcstore, name, _filefull, None))
if includeobsmarkers and repo.svfs.exists(b'obsstore'): if includeobsmarkers and repo.svfs.exists(b'obsstore'):

mercurial/upgrade_utils/engine.py

# key is unencoded filename # key is unencoded filename
# value is revlog_object_from_srcrepo # value is revlog_object_from_srcrepo
manifests = {} manifests = {}
changelogs = {} changelogs = {}
filelogs = {} filelogs = {}
# Perform a pass to collect metadata. This validates we can open all # Perform a pass to collect metadata. This validates we can open all
# source files and allows a unified progress bar to be displayed. # source files and allows a unified progress bar to be displayed.
for unencoded, encoded, size in alldatafiles: for revlog_type, unencoded, encoded, size in alldatafiles:
if not unencoded.endswith(b'.i'): if not unencoded.endswith(b'.i'):
continue continue
rl = _revlogfrompath(srcrepo, unencoded) rl = _revlogfrompath(srcrepo, unencoded)
info = rl.storageinfo( info = rl.storageinfo(
exclusivefiles=True, exclusivefiles=True,
revisionscount=True, revisionscount=True,

mercurial/verify.py

label, label,
) )
if not dir and subdirnodes: if not dir and subdirnodes:
self.ui.status(_(b"checking directory manifests\n")) self.ui.status(_(b"checking directory manifests\n"))
storefiles = set() storefiles = set()
subdirs = set() subdirs = set()
revlogv1 = self.revlogv1 revlogv1 = self.revlogv1
for f, f2, size in repo.store.datafiles(): for t, f, f2, size in repo.store.datafiles():
if not f: if not f:
self._err(None, _(b"cannot decode filename '%s'") % f2) self._err(None, _(b"cannot decode filename '%s'") % f2)
elif (size > 0 or not revlogv1) and f.startswith(b'meta/'): elif (size > 0 or not revlogv1) and f.startswith(b'meta/'):
storefiles.add(_normpath(f)) storefiles.add(_normpath(f))
subdirs.add(os.path.dirname(f)) subdirs.add(os.path.dirname(f))
subdirprogress = ui.makeprogress( subdirprogress = ui.makeprogress(
_(b'checking'), unit=_(b'manifests'), total=len(subdirs) _(b'checking'), unit=_(b'manifests'), total=len(subdirs)
) )
repo = self.repo repo = self.repo
ui = self.ui ui = self.ui
lrugetctx = self.lrugetctx lrugetctx = self.lrugetctx
revlogv1 = self.revlogv1 revlogv1 = self.revlogv1
havemf = self.havemf havemf = self.havemf
ui.status(_(b"checking files\n")) ui.status(_(b"checking files\n"))
storefiles = set() storefiles = set()
for f, f2, size in repo.store.datafiles(): for rl_type, f, f2, size in repo.store.datafiles():
if not f: if not f:
self._err(None, _(b"cannot decode filename '%s'") % f2) self._err(None, _(b"cannot decode filename '%s'") % f2)
elif (size > 0 or not revlogv1) and f.startswith(b'data/'): elif (size > 0 or not revlogv1) and f.startswith(b'data/'):
storefiles.add(_normpath(f)) storefiles.add(_normpath(f))
state = { state = {
# TODO this assumes revlog storage for changelog. # TODO this assumes revlog storage for changelog.
b'expectedversion': self.repo.changelog.version & 0xFFFF, b'expectedversion': self.repo.changelog.version & 0xFFFF,

mercurial/wireprotov2server.py

with repo.lock(): with repo.lock():
topfiles = list(repo.store.topfiles()) topfiles = list(repo.store.topfiles())
sendfiles = [] sendfiles = []
totalsize = 0 totalsize = 0
# TODO this is a bunch of storage layer interface abstractions because # TODO this is a bunch of storage layer interface abstractions because
# it assumes revlogs. # it assumes revlogs.
for name, encodedname, size in topfiles: for rl_type, name, encodedname, size in topfiles:
# XXX use the `rl_type` for that
if b'changelog' in files and name.startswith(b'00changelog'): if b'changelog' in files and name.startswith(b'00changelog'):
pass pass
elif b'manifestlog' in files and name.startswith(b'00manifest'): elif b'manifestlog' in files and name.startswith(b'00manifest'):
pass pass
else: else:
continue continue
sendfiles.append((b'store', name, size)) sendfiles.append((b'store', name, size))

tests/test-persistent-nodemap.t

stream clone stream clone
------------ ------------
The persistent nodemap should exist after a streaming clone The persistent nodemap should exist after a streaming clone
$ hg clone -U --stream --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/test-repo stream-clone --debug | egrep '00(changelog|manifest)' $ hg clone -U --stream --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/test-repo stream-clone --debug | egrep '00(changelog|manifest)'
adding [s] 00manifest.n (70 bytes) adding [s] 00manifest.n (70 bytes)
adding [s] 00manifest.i (313 KB)
adding [s] 00manifest.d (452 KB) adding [s] 00manifest.d (452 KB)
adding [s] 00manifest-*.nd (118 KB) (glob) adding [s] 00manifest-*.nd (118 KB) (glob)
adding [s] 00changelog.n (70 bytes) adding [s] 00changelog.n (70 bytes)
adding [s] 00changelog.i (313 KB)
adding [s] 00changelog.d (360 KB) adding [s] 00changelog.d (360 KB)
adding [s] 00changelog-*.nd (118 KB) (glob) adding [s] 00changelog-*.nd (118 KB) (glob)
adding [s] 00manifest.i (313 KB)
adding [s] 00changelog.i (313 KB)
$ ls -1 stream-clone/.hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)' $ ls -1 stream-clone/.hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
00changelog-*.nd (glob) 00changelog-*.nd (glob)
00changelog.n 00changelog.n
00manifest-*.nd (glob) 00manifest-*.nd (glob)
00manifest.n 00manifest.n
$ hg -R stream-clone debugnodemap --metadata $ hg -R stream-clone debugnodemap --metadata
uid: * (glob) uid: * (glob)
tip-rev: 5005 tip-rev: 5005
tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
data-length: 121088 data-length: 121088
data-unused: 0 data-unused: 0
data-unused: 0.000% data-unused: 0.000%