state.py
227 lines
| 8.5 KiB
| text/x-python
|
PythonLexer
/ mercurial / state.py
|
r38115 | # state.py - writing and reading state files in Mercurial | ||
# | ||||
# Copyright 2018 Pulkit Goyal <pulkitmgoyal@gmail.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
""" | ||||
This file contains class to wrap the state for commands and other | ||||
related logic. | ||||
All the data related to the command state is stored as dictionary in the object. | ||||
The class has methods using which the data can be stored to disk in a file under | ||||
.hg/ directory. | ||||
|
r41171 | We store the data on disk in cbor, for which we use the CBOR format to encode | ||
the data. | ||||
|
r38115 | """ | ||
from __future__ import absolute_import | ||||
|
r42729 | from .i18n import _ | ||
|
r38115 | from . import ( | ||
|
r38118 | error, | ||
|
r38115 | util, | ||
) | ||||
|
r39482 | from .utils import ( | ||
cborutil, | ||||
) | ||||
|
r38115 | |||
class cmdstate(object): | ||||
"""a wrapper class to store the state of commands like `rebase`, `graft`, | ||||
`histedit`, `shelve` etc. Extensions can also use this to write state files. | ||||
All the data for the state is stored in the form of key-value pairs in a | ||||
dictionary. | ||||
The class object can write all the data to a file in .hg/ directory and | ||||
can populate the object data reading that file. | ||||
Uses cbor to serialize and deserialize data while writing and reading from | ||||
disk. | ||||
""" | ||||
|
r38162 | def __init__(self, repo, fname): | ||
|
r38115 | """ repo is the repo object | ||
fname is the file name in which data should be stored in .hg directory | ||||
""" | ||||
self._repo = repo | ||||
self.fname = fname | ||||
|
r38116 | def read(self): | ||
"""read the existing state file and return a dict of data stored""" | ||||
return self._read() | ||||
|
r38115 | |||
|
r38118 | def save(self, version, data): | ||
|
r38115 | """write all the state data stored to .hg/<filename> file | ||
we use third-party library cbor to serialize data to write in the file. | ||||
""" | ||||
|
r38118 | if not isinstance(version, int): | ||
raise error.ProgrammingError("version of state file should be" | ||||
" an integer") | ||||
|
r38115 | with self._repo.vfs(self.fname, 'wb', atomictemp=True) as fp: | ||
|
r38140 | fp.write('%d\n' % version) | ||
|
r39482 | for chunk in cborutil.streamencode(data): | ||
fp.write(chunk) | ||||
|
r38115 | |||
def _read(self): | ||||
"""reads the state file and returns a dictionary which contain | ||||
data in the same format as it was before storing""" | ||||
with self._repo.vfs(self.fname, 'rb') as fp: | ||||
|
r38118 | try: | ||
|
r38141 | int(fp.readline()) | ||
|
r38118 | except ValueError: | ||
|
r38148 | raise error.CorruptedState("unknown version of state file" | ||
" found") | ||||
|
r39482 | |||
return cborutil.decodeall(fp.read())[0] | ||||
|
r38115 | |||
def delete(self): | ||||
"""drop the state file if exists""" | ||||
util.unlinkpath(self._repo.vfs.join(self.fname), ignoremissing=True) | ||||
def exists(self): | ||||
"""check whether the state file exists or not""" | ||||
return self._repo.vfs.exists(self.fname) | ||||
|
r42729 | |||
|
r42730 | class _statecheck(object): | ||
"""a utility class that deals with multistep operations like graft, | ||||
histedit, bisect, update etc and check whether such commands | ||||
are in an unfinished conditition or not and return appropriate message | ||||
and hint. | ||||
It also has the ability to register and determine the states of any new | ||||
multistep operation or multistep command extension. | ||||
""" | ||||
|
r42734 | def __init__(self, opname, fname, clearable, allowcommit, reportonly, | ||
|
r42784 | continueflag, stopflag, cmdmsg, cmdhint, statushint, | ||
abortfunc): | ||||
|
r42730 | self._opname = opname | ||
self._fname = fname | ||||
self._clearable = clearable | ||||
self._allowcommit = allowcommit | ||||
|
r42734 | self._reportonly = reportonly | ||
self._continueflag = continueflag | ||||
self._stopflag = stopflag | ||||
self._cmdmsg = cmdmsg | ||||
|
r42730 | self._cmdhint = cmdhint | ||
|
r42732 | self._statushint = statushint | ||
|
r42784 | self.abortfunc = abortfunc | ||
|
r42732 | |||
def statusmsg(self): | ||||
"""returns the hint message corresponding to the command for | ||||
hg status --verbose | ||||
""" | ||||
if not self._statushint: | ||||
hint = (_('To continue: hg %s --continue\n' | ||||
'To abort: hg %s --abort') % (self._opname, | ||||
self._opname)) | ||||
if self._stopflag: | ||||
hint = hint + (_('\nTo stop: hg %s --stop') % | ||||
(self._opname)) | ||||
return hint | ||||
return self._statushint | ||||
|
r42730 | |||
def hint(self): | ||||
|
r42732 | """returns the hint message corresponding to an interrupted | ||
operation | ||||
""" | ||||
|
r42730 | if not self._cmdhint: | ||
return (_("use 'hg %s --continue' or 'hg %s --abort'") % | ||||
(self._opname, self._opname)) | ||||
return self._cmdhint | ||||
def msg(self): | ||||
"""returns the status message corresponding to the command""" | ||||
if not self._cmdmsg: | ||||
return _('%s in progress') % (self._opname) | ||||
return self._cmdmsg | ||||
|
r42733 | def continuemsg(self): | ||
""" returns appropriate continue message corresponding to command""" | ||||
return _('hg %s --continue') % (self._opname) | ||||
|
r42730 | def isunfinished(self, repo): | ||
|
r42732 | """determines whether a multi-step operation is in progress | ||
or not | ||||
""" | ||||
if self._opname == 'merge': | ||||
return len(repo[None].parents()) > 1 | ||||
else: | ||||
return repo.vfs.exists(self._fname) | ||||
|
r42730 | |||
# A list of statecheck objects for multistep operations like graft. | ||||
_unfinishedstates = [] | ||||
|
r42734 | def addunfinished(opname, fname, clearable=False, allowcommit=False, | ||
reportonly=False, continueflag=False, stopflag=False, | ||||
|
r42784 | cmdmsg="", cmdhint="", statushint="", abortfunc=None): | ||
|
r42730 | """this registers a new command or operation to unfinishedstates | ||
|
r42734 | opname is the name the command or operation | ||
fname is the file name in which data should be stored in .hg directory. | ||||
It is None for merge command. | ||||
clearable boolean determines whether or not interrupted states can be | ||||
cleared by running `hg update -C .` which in turn deletes the | ||||
state file. | ||||
allowcommit boolean decides whether commit is allowed during interrupted | ||||
state or not. | ||||
reportonly flag is used for operations like bisect where we just | ||||
need to detect the operation using 'hg status --verbose' | ||||
continueflag is a boolean determines whether or not a command supports | ||||
`--continue` option or not. | ||||
stopflag is a boolean that determines whether or not a command supports | ||||
--stop flag | ||||
cmdmsg is used to pass a different status message in case standard | ||||
message of the format "abort: cmdname in progress" is not desired. | ||||
cmdhint is used to pass a different hint message in case standard | ||||
message of the format "To continue: hg cmdname --continue | ||||
To abort: hg cmdname --abort" is not desired. | ||||
statushint is used to pass a different status message in case standard | ||||
message of the format ('To continue: hg cmdname --continue' | ||||
'To abort: hg cmdname --abort') is not desired | ||||
|
r42784 | abortfunc stores the function required to abort an unfinished state. | ||
|
r42730 | """ | ||
|
r42734 | statecheckobj = _statecheck(opname, fname, clearable, allowcommit, | ||
reportonly, continueflag, stopflag, cmdmsg, | ||||
|
r42784 | cmdhint, statushint, abortfunc) | ||
|
r42732 | if opname == 'merge': | ||
_unfinishedstates.append(statecheckobj) | ||||
else: | ||||
_unfinishedstates.insert(0, statecheckobj) | ||||
|
r42730 | |||
addunfinished( | ||||
|
r42744 | 'unshelve', fname='shelvedstate', continueflag=True, | ||
cmdmsg=_('unshelve already in progress') | ||||
) | ||||
addunfinished( | ||||
|
r42730 | 'update', fname='updatestate', clearable=True, | ||
cmdmsg=_('last update was interrupted'), | ||||
|
r42732 | cmdhint=_("use 'hg update' to get a consistent checkout"), | ||
statushint=_("To continue: hg update") | ||||
|
r42730 | ) | ||
|
r42732 | addunfinished( | ||
'bisect', fname='bisect.state', allowcommit=True, reportonly=True, | ||||
statushint=_('To mark the changeset good: hg bisect --good\n' | ||||
'To mark the changeset bad: hg bisect --bad\n' | ||||
'To abort: hg bisect --reset\n') | ||||
) | ||||
addunfinished( | ||||
'merge', fname=None, clearable=True, allowcommit=True, | ||||
cmdmsg=_('outstanding uncommitted merge'), | ||||
statushint=_('To continue: hg commit\n' | ||||
'To abort: hg merge --abort'), | ||||
cmdhint=_("use 'hg commit' or 'hg merge --abort'") | ||||
|
r42731 | ) | ||
def getrepostate(repo): | ||||
# experimental config: commands.status.skipstates | ||||
skip = set(repo.ui.configlist('commands', 'status.skipstates')) | ||||
|
r42732 | for state in _unfinishedstates: | ||
if state._opname in skip: | ||||
|
r42731 | continue | ||
|
r42732 | if state.isunfinished(repo): | ||
return (state._opname, state.statusmsg()) | ||||