( )⚙ D10974 dirstate-entry: add a `need_delay` method

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10974

dirstate-entry: add a `need_delay` method
ClosedPublic

Authored by marmoute on Jul 4 2021, 5:51 PM.

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHGccbabaee5c36: dirstate-entry: add a `need_delay` method
Summary

This abstract the internal processing need for entry that would have an
ambiguous mtime (If I understand things correctly).

Diff Detail

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

Event Timeline

marmoute created this revision.Jul 4 2021, 5:51 PM
SimonSapin accepted this revision.Jul 5 2021, 1:21 AM
Alphare added a subscriber: Alphare.Jul 5 2021, 5:10 AM
Alphare added inline comments.
mercurial/pure/parsers.py
156

nit: needs_delay

pulkit accepted this revision.Jul 6 2021, 12:50 PM
This revision is now accepted and ready to land.Jul 6 2021, 12:50 PM
baymax updated this revision to Diff 28876.Jul 6 2021, 2:09 PM

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

marmoute added a commit: rHGccbabaee5c36: dirstate-entry: add a `need_delay` method.Jul 6 2021, 3:13 PM
Closed by commit rHGccbabaee5c36: dirstate-entry: add a `need_delay` method (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 28876

mercurial/cext/parsers.c

return PyInt_FromLong(self->size); return PyInt_FromLong(self->size);
}; };
static PyObject *dirstatetuple_v1_mtime(dirstateTupleObject *self) static PyObject *dirstatetuple_v1_mtime(dirstateTupleObject *self)
{ {
return PyInt_FromLong(self->mtime); return PyInt_FromLong(self->mtime);
}; };
static PyObject *dirstatetuple_need_delay(dirstateTupleObject *self,
PyObject *value)
{
long now;
if (!pylong_to_long(value, &now)) {
return NULL;
}
if (self->state == 'n' && self->mtime == now) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
};
static PyMethodDef dirstatetuple_methods[] = { static PyMethodDef dirstatetuple_methods[] = {
{"v1_state", (PyCFunction)dirstatetuple_v1_state, METH_NOARGS, {"v1_state", (PyCFunction)dirstatetuple_v1_state, METH_NOARGS,
"return a \"state\" suitable for v1 serialization"}, "return a \"state\" suitable for v1 serialization"},
{"v1_mode", (PyCFunction)dirstatetuple_v1_mode, METH_NOARGS, {"v1_mode", (PyCFunction)dirstatetuple_v1_mode, METH_NOARGS,
"return a \"mode\" suitable for v1 serialization"}, "return a \"mode\" suitable for v1 serialization"},
{"v1_size", (PyCFunction)dirstatetuple_v1_size, METH_NOARGS, {"v1_size", (PyCFunction)dirstatetuple_v1_size, METH_NOARGS,
"return a \"size\" suitable for v1 serialization"}, "return a \"size\" suitable for v1 serialization"},
{"v1_mtime", (PyCFunction)dirstatetuple_v1_mtime, METH_NOARGS, {"v1_mtime", (PyCFunction)dirstatetuple_v1_mtime, METH_NOARGS,
"return a \"mtime\" suitable for v1 serialization"}, "return a \"mtime\" suitable for v1 serialization"},
{"need_delay", (PyCFunction)dirstatetuple_need_delay, METH_O,
"True if the stored mtime would be ambiguous with the current time"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstatetuple_get_state(dirstateTupleObject *self) static PyObject *dirstatetuple_get_state(dirstateTupleObject *self)
{ {
return PyBytes_FromStringAndSize(&self->state, 1); return PyBytes_FromStringAndSize(&self->state, 1);
}; };

mercurial/dirstate.py

now = util.fstat(st)[stat.ST_MTIME] & _rangemask now = util.fstat(st)[stat.ST_MTIME] & _rangemask
# enough 'delaywrite' prevents 'pack_dirstate' from dropping # enough 'delaywrite' prevents 'pack_dirstate' from dropping
# timestamp of each entries in dirstate, because of 'now > mtime' # timestamp of each entries in dirstate, because of 'now > mtime'
delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite') delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite')
if delaywrite > 0: if delaywrite > 0:
# do we have any files to delay for? # do we have any files to delay for?
for f, e in pycompat.iteritems(self._map): for f, e in pycompat.iteritems(self._map):
if e.state == b'n' and e[3] == now: if e.need_delay(now):
import time # to avoid useless import import time # to avoid useless import
# rather than sleep n seconds, sleep until the next # rather than sleep n seconds, sleep until the next
# multiple of n seconds # multiple of n seconds
clock = time.time() clock = time.time()
start = int(clock) - (int(clock) % delaywrite) start = int(clock) - (int(clock) % delaywrite)
end = start + delaywrite end = start + delaywrite
time.sleep(end - clock) time.sleep(end - clock)

mercurial/pure/parsers.py

def v1_size(self): def v1_size(self):
"""return a "size" suitable for v1 serialization""" """return a "size" suitable for v1 serialization"""
return self._size return self._size
def v1_mtime(self): def v1_mtime(self):
"""return a "mtime" suitable for v1 serialization""" """return a "mtime" suitable for v1 serialization"""
return self._mtime return self._mtime
def need_delay(self, now):
AlphareUnsubmitted
Not Done

nit: needs_delay

Alphare: nit: `needs_delay`
"""True if the stored mtime would be ambiguous with the current time"""
return self._state == b'n' and self._mtime == now
def gettype(q): def gettype(q):
return int(q & 0xFFFF) return int(q & 0xFFFF)
class BaseIndexObject(object): class BaseIndexObject(object):
# Can I be passed to an algorithme implemented in Rust ? # Can I be passed to an algorithme implemented in Rust ?
rust_ext_compat = 0 rust_ext_compat = 0