run-tests: remove obsolete coverage check and packaging import (issue6805) This removes an obsolete `coverage` version check (version from a decade ago). This also conveniently removes the dependency over `packaging.version`, which requires some additional installation since Python 3.10.

test-tx-rollback: more lenient glob for kill status (issue6807) The "killed" message may have some prefix and/or suffix which differ depending on the platform. This makes the pinned test output more lenient to accept those.

commands: correct documentation of hg serve’s --ipv6 option When the --ipv6 option is given, the server doesn’t listen to a IPv4 socket. This can be verified by running two servers, one with and one without the option, which works fine. I think that listening to both a IPv4 and a IPv6 socket would be better, but given that the Python standard library class underlying the HTTP server supports only one socket, this is not trivial.

rhg: don't crash on empty directory names in path_encode, just in case I don't expect that to be possible, but there's nothing in path_encode.rs that prevents it, and the old code didn't crash in this case, so it's better to be defensive.

rhg: fix a bug in path encoding, demonstrated in the parent commit

rhg: show a bug in the rust implementation of path_encode introduced recently In commit 96d31efd21f7 I did a refactoring where I dropped a chunk of code by accident, thus introducing a bug. This commit adds a test demonstrating that bug.

typing: correct the signature of error.CommandError There's a place in `mercurial.dispatch._parse()` that passes None if a parse error happens before the command can be parsed out, and casting the error to bytes works fine because the command and message fields are apparently ignored. Likewise, TortoiseHg similarly passes None for the same reason.

Added signature for changeset f14864fffdca

Added tag 6.4 for changeset f14864fffdca

relnotes: do 6.4

hooks: invalidate the repo after the hooks Since the hooks may have changed the repository content it seems safer to invalidate it. The invalidation is "soft", the data are kept around and few work will be needed to restore them if nothing actually changed.

dirstate: try refreshing the changelog when parent are unknown See inline comment for details.

localrepo: add a `currentlock` method It mirrors he `currentwlock` function.

dirstate: add a test to highlight another changelog / dirstate race

rust: fix thread cap (for real this time) Both e2f8ed37201c and c52435820bbd failed to put a *default* ceiling on the number of threads used by Rayon to prevent a contention issue. Calling `rayon::available_parallelism()` creates the global threadpool, which made our whole dance useless last time.

tests: accept a test output change in [tests/test-serve.t] This fixes a breakage introduced in adecb1ab4a0d. It was not caught by the CI probably because allows binding to port 13.

py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Missed in 805d4a462abb: $ python3.12 mercurial/store.py mercurial/store.py:406: SyntaxWarning: invalid escape sequence '\.' EXCLUDED = re.compile(b'.*undo\.[^/]+\.(nd?|i)$')

url: don't ignore timeout for https connections For http, we use the stdlib's HTTPConnection.connect which passes the timeout down to socket.create_connection; for https, we override the connect method but weren't handling the timeout, so connections could hang for hours even with http.timeout set to low values.

debugdeltachain: stop summing the same chain over and over Before this patch, delta chain size was computed from scratch for each chain, disregarding the fact very likely already computed the same of length-1 prefix for another revisions. We not cache delta chain size and shortcut the computation when we see them. Just for my mercurial-devel clone, this move the computation from about 17.5 second to about 4.8 seconds.

revlog: improve the robustness of the splitting process The previous "in-place" splitting, preserving the splitting on transaction failure had a couple of issue in case of transaction rollback: - a race windows that could still lead to a crash and data loss - it corrupted the `fncache`. So instead, we use a new approach that we summarized as "we do a backup of the inline revlog pre-split, and we restore this in case of failure". To make readers live easier, we don't overwrite the inline index file until transaction finalization. (once the transaction get into its finalization phase, it is not expected to rollback, unless some crash happens). To do so, we write the index of the split index in a temporary file that we use until transaction finalization. We also keep a backup of the initial inline file to be able to rollback the split if needed. As a result, transaction rollback cancel the split and no longer corrupt fncache. We also no longer have a small inconsistency windows where the transaction could be unrecoverable.

fncache: make it possible to ignore some file In the next changeset, we need to able to ignore some temporary file. This changeset teach the fncache about that.

revlog: test that pending hooks properly see the repository on split This seems important to explicitly cover this case before changing the code.

revlog: test possible read race condition with splitting This is currently working fine, but could break with another approach (for example, with the one we are about to use in the next changesets…) So we make sure the case is covered.

revlog: add a failing variant of the the split + transaction test We have another variant to tests, and it is crashing… So lets cover it with tests.

revlog: update the split + transaction test We add section, increase the amount of comments and simplify some of the constructs. We are about to build more on top this tests so lets do a small cleanup first.

transaction: allow to backup file that already have an offset This will be useful in the next changeset to deal with rolling back the split of inline revlog on transaction failure. This involve deeper change to the transaction logic as we need to make sure we restore the backup -before- the truncation step. Otherwise, the truncation would act on the wrong file and be overwritten by the backup restoration later.

transaction: move the restoration of backup file in a small closure We are about to use that logic in two different location, making is a small reusable closure prepares that.

transaction: raise on backup restoration error A few line above, similar errors in the truncation code result in raising the associated exception. We should do the same here. This means the transaction recover is more strict now, which might be a problem when running `hg recover` in a share different from the one where the transaction fails. However this has always been a problem and need to be be addressed independently.

transaction: add clarifying comment about why ignoring some error is fine It is less scary when explained.

transaction: properly clean up backup file outside of .hg/store/ Oops.

statprof: with Python 3.12, lineno is (more) often None test-profile.t failed with errors like: TypeError: %d format: a real number is required, not NoneType statprof.py already handled None values as -1 in some cases. Do the same in more cases.

py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mercurial became very noisy after https://github.com/python/cpython/commit/a60ddd31be7ff96a8189e7483bf1eb2071d2bddf , for example: $ python3.12 mercurial/store.py mercurial/store.py:406: SyntaxWarning: invalid escape sequence '\.' EXCLUDED = re.compile(b'.*undo\.[^/]+\.(nd?|i)$') This verbosity made some tests fail. The problems were mostly insufficiently escaped regexps, relying on the Python parser/scanner preserving invalid escape sequences.

cext: fix for PyLong refactoring in CPython 3.12 Compiling Mercurial with Python 3.12 a5 would fail with: mercurial/cext/dirs.c: In function '_addpath': mercurial/cext/dirs.c:19:44: error: 'PyLongObject' {aka 'struct _longobject'} has no member named 'ob_digit' 19 | #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0] | ^~ mercurial/cext/dirs.c:97:25: note: in expansion of macro 'PYLONG_VALUE' 97 | PYLONG_VALUE(val) += 1; | ^~~~~~~~~~~~ mercurial/cext/dirs.c:19:44: error: 'PyLongObject' {aka 'struct _longobject'} has no member named 'ob_digit' 19 | #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0] | ^~ mercurial/cext/dirs.c:108:17: note: in expansion of macro 'PYLONG_VALUE' 108 | PYLONG_VALUE(val) = 1; | ^~~~~~~~~~~~ mercurial/cext/dirs.c: In function '_delpath': mercurial/cext/dirs.c:19:44: error: 'PyLongObject' {aka 'struct _longobject'} has no member named 'ob_digit' 19 | #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0] | ^~ mercurial/cext/dirs.c:145:23: note: in expansion of macro 'PYLONG_VALUE' 145 | if (--PYLONG_VALUE(val) <= 0) { | ^~~~~~~~~~~~ This was caused by https://github.com/python/cpython/commit/c1b1f51cd1632f0b77dacd43092fb44ed5e053a9 .

histedit: fix diff colors The problem here is that indexing a bytestring gives you integers, not chars, so the comparison to b'+' ends up being wrong. We don't really have a way to test curses output, so no tests to verify the correctness of this behaviour.

dirstate: fix a potential traceback when in `copy` and `rename` Before this changes, calling `hg copy` or `hg rename` could trigger a traceback about using an invalidated dirstate. This wasn't caught by the test as it needed the blackbox extension to preload the dirstate first in a way "refresh" invalidates it. Changing the context creation patterns fixes it.

dirstate: fix the bug in [status] dealing with committed&ignored directories In particular, these directories can "infect" their sibling directories with ignored status due to using a shared memoization cell by accident. This fixes bug #6795.

tests: demonstrate a bug with committed&ignored dirs

rust: remove out-of-date comment We've migrated to a newer version of Rust, so it doesn't make sense anymore.

rust: upgrade `rayon` dependency This includes a potential soundness fix as well as some improvements to performance which should be helpful.

rust: update zstd dependency Let's try to be the most up-to-date for this cycle. Fedora already has this version packaged, it's an added bonus.

tests: simplify a bit

dirstate-v2: fix an incorrect handling of readdir errors Make sure not to cache the results of a failed readdir call.

tests: demonstrate a bug in dirstate-v2 handling of errors

tests: add a rewriting step to detect EACCES errors

undo-files: cleanup legacy files when applicable The "journal" code is much more compact in 6.4, and so is the "undo" files as a result. However the previous version were much noisier, so let us cleanup undo files from older version too.

undo-files: clean existing files up before writing new one the in the initial design of journal/undo interaction, ages ago, new file always overwrote previous files. This is no longer the case for a long while, so it is time to properly clean things up before writing new ones. Otherwise, inconsistent "undo" state might exist on disk, leading `hg rollback` to misbehave (more that intended).

undo-files: make the undo-prefix configurable in `cleanup_undo_files` The transaction is configuration undo prefix, so we "need" it too.

undo-files: no longer pass the `repo` to `cleanup_undo_files` As foretold in the previous changesets, we no longer need a full repository object here.

undo-files: relies on a explicit list of possible undo files Instead of infering the list of undo files from the `_journalfiles` method on `localrepository`, we explicitly have the list of file in a constant next to the cleanup code. In practice this does not change much as `_journalfiles` is already returning the same "static" list and no internal or extensions extensions seems to actually wrap that. In addition, that list is not "too short" for cleanup, in case we need to cleanup undo files from older version of Mercurial that used to use more of them. this will be dealt with in a later changesets. This change is a step toward our goal to use the `cleanup_undo_files` within the transaction. The transaction has no reference to the `repo` object, so we need to move toward `cleanup_undo_files` not having one either.

undo-files: move the undo cleanup code in the transaction module Now that undo creation is gathered in the transaction module, let us move the code cleaning them up there too. This will be useful to better clean previous undo files up before creating new ones.

undo-files: drop the old undo rename logic It is no longer necessary I am not changing the transaction.__init__ signature since we are on stable right now.

undo-files: have the transaction directly tracks and manages journal rename This is much simpler this way.

undo-files: add a undoname closure to the _write_undo method We will also needs it when the transaction will take care of the other journal files, which is soon™.

undo-files: cleanup backup when cleaning undos Previously, the backups were left behind, by operation cleaning the undo's like strip, narrow and stream clone. The remaining elevant in the room is the transaction itself, who does not properly cleanup undo backup before copying the new ones.

undo-files: factor the vfs map in a repository property We define it in multiple locations and inconsistencies are appearing. So we now have a single definition point.

undo-files: add a utility function to read the backup-files definition We will need it in multiple places. so lets factor the logic around.

undo-files: use the cleanup function in streamclone Lets use the same code, so that we can fix things only once.

undo-files: also remove the undo.backupfiles The undo.backupfiles is dealt is directly managed by the transaction instead of going through the `localrepo.undofiles`. We start doing minimal management for it before using `cleanup_undo_files` on more situation. Proper handling of it is an intermediate goal of this series.

undo-files: use the cleanup function in narrow Lets use the same code, so that we can fix things only once.

undo-files: extract the cleanup code from strip in a function This logic is duplicated in multiple places and it missing some important parts. So lets start dealing with the duplication first.