This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9738

shelve: replace repo instance in Shelf class by vfs instance
ClosedPublic

Authored by martinvonz on Jan 12 2021, 5:48 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGe2713c68b477: shelve: replace repo instance in Shelf class by vfs instance
rHG20b6d76e7f1c: shelve: replace repo instance in Shelf class by vfs instance
rHGba9be8f53c93: shelve: replace repo instance in Shelf class by vfs instance
Summary

I'd like to be able to teach the Shelf class to read shelves from
.hg/shelve-backup/ in addition to .hg/shelved/. That means that
we'll have to pass in a vfs instead of the repo, so this patch does
that preparation.

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.

Revision Contents
Changeset List

PathPackages
Mmercurial/shelve.py (78 lines)

Diff 24953

mercurial/shelve.py

class Shelf(object): class Shelf(object):
"""Represents a shelf, including possibly multiple files storing it. """Represents a shelf, including possibly multiple files storing it.
Old shelves will have a .patch and a .hg file. Newer shelves will Old shelves will have a .patch and a .hg file. Newer shelves will
also have a .shelve file. This class abstracts away some of the also have a .shelve file. This class abstracts away some of the
differences and lets you work with the shelf as a whole. differences and lets you work with the shelf as a whole.
""" """
def __init__(self, repo, name): def __init__(self, vfs, name):
self.repo = repo self.vfs = vfs
self.name = name self.name = name
self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
self.backupvfs = vfsmod.vfs(repo.vfs.join(backupdir)) @staticmethod
def open(repo, name):
return Shelf(vfsmod.vfs(repo.vfs.join(shelvedir)), name)
def exists(self): def exists(self):
return self.vfs.exists( return self.vfs.exists(
self.name + b'.' + patchextension self.name + b'.' + patchextension
) and self.vfs.exists(self.name + b'.hg') ) and self.vfs.exists(self.name + b'.hg')
def mtime(self): def mtime(self):
return self.vfs.stat(self.name + b'.' + patchextension)[stat.ST_MTIME] return self.vfs.stat(self.name + b'.' + patchextension)[stat.ST_MTIME]
def writeinfo(self, info): def writeinfo(self, info):
scmutil.simplekeyvaluefile(self.vfs, self.name + b'.shelve').write(info) scmutil.simplekeyvaluefile(self.vfs, self.name + b'.shelve').write(info)
def hasinfo(self): def hasinfo(self):
return self.vfs.exists(self.name + b'.shelve') return self.vfs.exists(self.name + b'.shelve')
def readinfo(self): def readinfo(self):
return scmutil.simplekeyvaluefile( return scmutil.simplekeyvaluefile(
self.vfs, self.name + b'.shelve' self.vfs, self.name + b'.shelve'
).read() ).read()
def writebundle(self, bases, node): def writebundle(self, repo, bases, node):
cgversion = changegroup.safeversion(self.repo) cgversion = changegroup.safeversion(repo)
if cgversion == b'01': if cgversion == b'01':
btype = b'HG10BZ' btype = b'HG10BZ'
compression = None compression = None
else: else:
btype = b'HG20' btype = b'HG20'
compression = b'BZ' compression = b'BZ'
repo = self.repo.unfiltered() repo = repo.unfiltered()
outgoing = discovery.outgoing( outgoing = discovery.outgoing(
repo, missingroots=bases, ancestorsof=[node] repo, missingroots=bases, ancestorsof=[node]
) )
cg = changegroup.makechangegroup(repo, outgoing, cgversion, b'shelve') cg = changegroup.makechangegroup(repo, outgoing, cgversion, b'shelve')
bundle_filename = self.vfs.join(self.name + b'.hg') bundle_filename = self.vfs.join(self.name + b'.hg')
bundle2.writebundle( bundle2.writebundle(
self.repo.ui, repo.ui,
cg, cg,
bundle_filename, bundle_filename,
btype, btype,
self.vfs, self.vfs,
compression=compression, compression=compression,
) )
def applybundle(self, tr): def applybundle(self, repo, tr):
filename = self.name + b'.hg' filename = self.name + b'.hg'
fp = self.vfs(filename) fp = self.vfs(filename)
try: try:
targetphase = phases.internal targetphase = phases.internal
if not phases.supportinternal(self.repo): if not phases.supportinternal(repo):
targetphase = phases.secret targetphase = phases.secret
gen = exchange.readbundle(self.repo.ui, fp, filename, self.vfs) gen = exchange.readbundle(repo.ui, fp, filename, self.vfs)
pretip = self.repo[b'tip'] pretip = repo[b'tip']
bundle2.applybundle( bundle2.applybundle(
self.repo, repo,
gen, gen,
tr, tr,
source=b'unshelve', source=b'unshelve',
url=b'bundle:' + self.vfs.join(filename), url=b'bundle:' + self.vfs.join(filename),
targetphase=targetphase, targetphase=targetphase,
) )
shelvectx = self.repo[b'tip'] shelvectx = repo[b'tip']
if pretip == shelvectx: if pretip == shelvectx:
shelverev = tr.changes[b'revduplicates'][-1] shelverev = tr.changes[b'revduplicates'][-1]
shelvectx = self.repo[shelverev] shelvectx = repo[shelverev]
return shelvectx return shelvectx
finally: finally:
fp.close() fp.close()
def open_patch(self, mode=b'rb'): def open_patch(self, mode=b'rb'):
return self.vfs(self.name + b'.patch', mode) return self.vfs(self.name + b'.patch', mode)
def _backupfilename(self, filename): def _backupfilename(self, backupvfs, filename):
def gennames(base): def gennames(base):
yield base yield base
base, ext = base.rsplit(b'.', 1) base, ext = base.rsplit(b'.', 1)
for i in itertools.count(1): for i in itertools.count(1):
yield b'%s-%d.%s' % (base, i, ext) yield b'%s-%d.%s' % (base, i, ext)
for n in gennames(filename): for n in gennames(filename):
if not self.backupvfs.exists(n): if not backupvfs.exists(n):
return self.backupvfs.join(n) return backupvfs.join(n)
def movetobackup(self): def movetobackup(self, backupvfs):
if not self.backupvfs.isdir(): if not backupvfs.isdir():
self.backupvfs.makedir() backupvfs.makedir()
for suffix in shelvefileextensions: for suffix in shelvefileextensions:
filename = self.name + b'.' + suffix filename = self.name + b'.' + suffix
if self.vfs.exists(filename): if self.vfs.exists(filename):
util.rename( util.rename(
self.vfs.join(filename), self._backupfilename(filename) self.vfs.join(filename),
self._backupfilename(backupvfs, filename),
) )
class shelvedstate(object): class shelvedstate(object):
"""Handle persistence during unshelving operations. """Handle persistence during unshelving operations.
Handles saving and restoring a shelved state. Ensures that different Handles saving and restoring a shelved state. Ensures that different
versions of a shelved state are possible and handles them appropriately. versions of a shelved state are possible and handles them appropriately.
# slashes aren't allowed in filenames, therefore we rename it # slashes aren't allowed in filenames, therefore we rename it
label = label.replace(b'/', b'_') label = label.replace(b'/', b'_')
label = label.replace(b'\\', b'_') label = label.replace(b'\\', b'_')
# filenames must not start with '.' as it should not be hidden # filenames must not start with '.' as it should not be hidden
if label.startswith(b'.'): if label.startswith(b'.'):
label = label.replace(b'.', b'_', 1) label = label.replace(b'.', b'_', 1)
if name: if name:
if Shelf(repo, name).exists(): if Shelf.open(repo, name).exists():
e = _(b"a shelved change named '%s' already exists") % name e = _(b"a shelved change named '%s' already exists") % name
raise error.Abort(e) raise error.Abort(e)
# ensure we are not creating a subdirectory or a hidden file # ensure we are not creating a subdirectory or a hidden file
if b'/' in name or b'\\' in name: if b'/' in name or b'\\' in name:
raise error.Abort( raise error.Abort(
_(b'shelved change names can not contain slashes') _(b'shelved change names can not contain slashes')
) )
if name.startswith(b'.'): if name.startswith(b'.'):
raise error.Abort(_(b"shelved change names can not start with '.'")) raise error.Abort(_(b"shelved change names can not start with '.'"))
else: else:
for n in gennames(): for n in gennames():
if not Shelf(repo, n).exists(): if not Shelf.open(repo, n).exists():
name = n name = n
break break
return name return name
def mutableancestors(ctx): def mutableancestors(ctx):
"""return all mutable ancestors for ctx (included) """return all mutable ancestors for ctx (included)
% len(stat.deleted) % len(stat.deleted)
) )
else: else:
ui.status(_(b"nothing changed\n")) ui.status(_(b"nothing changed\n"))
def _shelvecreatedcommit(repo, node, name, match): def _shelvecreatedcommit(repo, node, name, match):
info = {b'node': hex(node)} info = {b'node': hex(node)}
shelf = Shelf(repo, name) shelf = Shelf.open(repo, name)
shelf.writeinfo(info) shelf.writeinfo(info)
bases = list(mutableancestors(repo[node])) bases = list(mutableancestors(repo[node]))
shelf.writebundle(bases, node) shelf.writebundle(repo, bases, node)
with shelf.open_patch(b'wb') as fp: with shelf.open_patch(b'wb') as fp:
cmdutil.exportfile( cmdutil.exportfile(
repo, [node], fp, opts=mdiff.diffopts(git=True), match=match repo, [node], fp, opts=mdiff.diffopts(git=True), match=match
) )
def _includeunknownfiles(repo, pats, opts, extra): def _includeunknownfiles(repo, pats, opts, extra):
s = repo.status(match=scmutil.match(repo[None], pats, opts), unknown=True) s = repo.status(match=scmutil.match(repo[None], pats, opts), unknown=True)
def _iswctxonnewbranch(repo): def _iswctxonnewbranch(repo):
return repo[None].branch() != repo[b'.'].branch() return repo[None].branch() != repo[b'.'].branch()
def cleanupcmd(ui, repo): def cleanupcmd(ui, repo):
"""subcommand that deletes all shelves""" """subcommand that deletes all shelves"""
with repo.wlock(): with repo.wlock():
backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
for _mtime, name in listshelves(repo): for _mtime, name in listshelves(repo):
Shelf(repo, name).movetobackup() Shelf.open(repo, name).movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
def deletecmd(ui, repo, pats): def deletecmd(ui, repo, pats):
"""subcommand that deletes a specific shelve""" """subcommand that deletes a specific shelve"""
if not pats: if not pats:
raise error.InputError(_(b'no shelved changes specified!')) raise error.InputError(_(b'no shelved changes specified!'))
with repo.wlock(): with repo.wlock():
backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
for name in pats: for name in pats:
shelf = Shelf(repo, name) shelf = Shelf.open(repo, name)
if not shelf.exists(): if not shelf.exists():
raise error.InputError( raise error.InputError(
_(b"shelved change '%s' not found") % name _(b"shelved change '%s' not found") % name
) )
shelf.movetobackup() shelf.movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
def listshelves(repo): def listshelves(repo):
"""return all shelves in repo as list of (time, name)""" """return all shelves in repo as list of (time, name)"""
try: try:
names = repo.vfs.listdir(shelvedir) names = repo.vfs.listdir(shelvedir)
except OSError as err: except OSError as err:
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
return [] return []
info = [] info = []
seen = set() seen = set()
for filename in names: for filename in names:
name = filename.rsplit(b'.', 1)[0] name = filename.rsplit(b'.', 1)[0]
if name in seen: if name in seen:
continue continue
seen.add(name) seen.add(name)
shelf = Shelf(repo, name) shelf = Shelf.open(repo, name)
if not shelf.exists(): if not shelf.exists():
continue continue
mtime = shelf.mtime() mtime = shelf.mtime()
info.append((mtime, name)) info.append((mtime, name))
return sorted(info, reverse=True) return sorted(info, reverse=True)
def listcmd(ui, repo, pats, opts): def listcmd(ui, repo, pats, opts):
continue continue
ui.write(b' ' * (16 - len(name))) ui.write(b' ' * (16 - len(name)))
used = 16 used = 16
date = dateutil.makedate(mtime) date = dateutil.makedate(mtime)
age = b'(%s)' % templatefilters.age(date, abbrev=True) age = b'(%s)' % templatefilters.age(date, abbrev=True)
ui.write(age, label=b'shelve.age') ui.write(age, label=b'shelve.age')
ui.write(b' ' * (12 - len(age))) ui.write(b' ' * (12 - len(age)))
used += 12 used += 12
with Shelf(repo, name).open_patch() as fp: with Shelf.open(repo, name).open_patch() as fp:
while True: while True:
line = fp.readline() line = fp.readline()
if not line: if not line:
break break
if not line.startswith(b'#'): if not line.startswith(b'#'):
desc = line.rstrip() desc = line.rstrip()
if ui.formatted(): if ui.formatted():
desc = stringutil.ellipsis(desc, width - used) desc = stringutil.ellipsis(desc, width - used)
if len(pats) == 0: if len(pats) == 0:
shelves = listshelves(repo) shelves = listshelves(repo)
if not shelves: if not shelves:
raise error.Abort(_(b"there are no shelves to show")) raise error.Abort(_(b"there are no shelves to show"))
mtime, name = shelves[0] mtime, name = shelves[0]
pats = [name] pats = [name]
for shelfname in pats: for shelfname in pats:
if not Shelf(repo, shelfname).exists(): if not Shelf.open(repo, shelfname).exists():
raise error.Abort(_(b"cannot find shelf %s") % shelfname) raise error.Abort(_(b"cannot find shelf %s") % shelfname)
listcmd(ui, repo, pats, opts) listcmd(ui, repo, pats, opts)
def checkparents(repo, state): def checkparents(repo, state):
"""check parent while resuming an unshelve""" """check parent while resuming an unshelve"""
if state.parents != repo.dirstate.parents(): if state.parents != repo.dirstate.parents():
ui.status( ui.status(
_(b'marked working directory as branch %s\n') % branchtorestore _(b'marked working directory as branch %s\n') % branchtorestore
) )
def unshelvecleanup(ui, repo, name, opts): def unshelvecleanup(ui, repo, name, opts):
"""remove related files after an unshelve""" """remove related files after an unshelve"""
if not opts.get(b'keep'): if not opts.get(b'keep'):
Shelf(repo, name).movetobackup() backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
Shelf.open(repo, name).movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
def unshelvecontinue(ui, repo, state, opts): def unshelvecontinue(ui, repo, state, opts):
"""subcommand to continue an in-progress unshelve""" """subcommand to continue an in-progress unshelve"""
# We're finishing off a merge. First parent is our original # We're finishing off a merge. First parent is our original
# parent, second is the temporary "fake" commit we're unshelving. # parent, second is the temporary "fake" commit we're unshelving.
interactive = state.interactive interactive = state.interactive
tmpwctx = repo[node] tmpwctx = repo[node]
return tmpwctx, addedbefore return tmpwctx, addedbefore
def _unshelverestorecommit(ui, repo, tr, basename): def _unshelverestorecommit(ui, repo, tr, basename):
"""Recreate commit in the repository during the unshelve""" """Recreate commit in the repository during the unshelve"""
repo = repo.unfiltered() repo = repo.unfiltered()
node = None node = None
shelf = Shelf(repo, basename) shelf = Shelf.open(repo, basename)
if shelf.hasinfo(): if shelf.hasinfo():
node = shelf.readinfo()[b'node'] node = shelf.readinfo()[b'node']
if node is None or node not in repo: if node is None or node not in repo:
with ui.configoverride({(b'ui', b'quiet'): True}): with ui.configoverride({(b'ui', b'quiet'): True}):
shelvectx = shelf.applybundle(tr) shelvectx = shelf.applybundle(repo, tr)
# We might not strip the unbundled changeset, so we should keep track of # We might not strip the unbundled changeset, so we should keep track of
# the unshelve node in case we need to reuse it (eg: unshelve --keep) # the unshelve node in case we need to reuse it (eg: unshelve --keep)
if node is None: if node is None:
info = {b'node': hex(shelvectx.node())} info = {b'node': hex(shelvectx.node())}
shelf.writeinfo(info) shelf.writeinfo(info)
else: else:
shelvectx = repo[node] shelvectx = repo[node]
shelved = listshelves(repo) shelved = listshelves(repo)
if not shelved: if not shelved:
raise error.StateError(_(b'no shelved changes to apply!')) raise error.StateError(_(b'no shelved changes to apply!'))
basename = shelved[0][1] basename = shelved[0][1]
ui.status(_(b"unshelving change '%s'\n") % basename) ui.status(_(b"unshelving change '%s'\n") % basename)
else: else:
basename = shelved[0] basename = shelved[0]
if not Shelf(repo, basename).exists(): if not Shelf.open(repo, basename).exists():
raise error.InputError(_(b"shelved change '%s' not found") % basename) raise error.InputError(_(b"shelved change '%s' not found") % basename)
return _dounshelve(ui, repo, basename, opts) return _dounshelve(ui, repo, basename, opts)
def _dounshelve(ui, repo, basename, opts): def _dounshelve(ui, repo, basename, opts):
repo = repo.unfiltered() repo = repo.unfiltered()
lock = tr = None lock = tr = None