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.

help: fix formatting for http config section

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.

branching: merge stable into default

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.

fastexport: rework newline logic Newlines should only be added when otherwise the stream would look weird without them (on blobs), therefore they are the exception. Flip the logic so they are added, not skipped.

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

encoding: avoid quadratic time complexity when json-encoding non-UTF8 strings Apparently the code uses "+=" with a bytes object, which is linear-time, so the whole encoding is quadratic-time. This patch makes us use a bytearray object, instead, which has a(n amortized-)constant-time append operation. The encoding is still not particularly fast, but at least a 10MB file takes tens of seconds, not many hours to encode.

bundle: prevent implicite bundling of internal changeset Now that the two mains source of on-disk bundle are preventing the inclusion of internal changesets in their bundling. We can add a lower level check that would prevent any other leakage of internal-phase changesets. We keep the door open to some usage, like the temporary bundle using during strip for example.

bundle: abort if the user request bundling of internal changesets See inline comments for details.

strip: do now include internal changeset in the strip backup See inline comment for details.

revset: add `_internal()` predicate This predicate help core code to select internal changeset (in the internal phase).

strip: drop the assert about bundled revision This is working well, so no need for extract computation. See the previous changeset for the rationnal of still have these assert around for a short interval.

strip: explicitly compute the boundary of the backup bundle We want to make change to the set of backed up revision in a future changeset, we start with a change of the computation without any changes in the semantic to clarify later changeset. The could of costly assert are here to testify that the result is still correct. They will be removed in the next changesets, but I wanted them in this changeset to help in case someone bisect a regression to this changeset in the future.

outgoing: fix common-heads computation from `missingroots` argument When initializing a `outgoing` object, the `common set` can be defined explicitly (with the `commonheads` argument`) or implicitly (with the missingroots arguments). It turns out the logic to compute `commonheads` from `missingroots` is buggy, as it does not consider the parents of enough changesets. Previously, it only considered parents of "missingroots` items, while it need to consider all parents of missing. Here is an example: F |\ C E | | B D |/ A If we use [E] as missing-roots, the missing set is [E, F], and the common-heads are [C, D]. However you cannot only consider the parent of [E] to find them, as [C] is not a parent of [E]. This already fix the bundle generated in one test, and it would prevent many other to misbehave with future change from this series.

bundle: include required phases when saving a bundle (issue6794) We now properly computes and includes phases above secret in bundle, previously, they would be skipped, and then the code computing them would crash. Note that from this changeset, we also include the heads associated with the changegroup's "target" phase. This turned out to be necessary to ensure the movement of changeset included in the bundle, but already known locally. This explain why lines for "secret" heads appears in multiple tests.

bundle: add test bundling changeset in the "archived" phase Having this test highlight that phase bundling above secret is significantly broken. Fixes coming in the next changesets.

bundle: introduce a "v3" spec This is a small update from "v2", we use the freshly out of experimental changelog version "03' format (alignment with bundle version is a coincidence) and we now bundle phases by default. We shall use v3 as the default bundle type later, when changegroup version '03' is a bit more established

bundle: add some phase boundary in the bundle type test case Same logic as the previous one, we want the tests to cover richer cases. It actually reveal a bug in `hg bundle foo.hg REMOTE` involving secret. So this is definitly not a bad idea.

bundle: expand the graph we us for bundletype/bundlespec tests We are about to test more things, especially phase bundling, so we need a graph a bit more complex than a single node. The test "code" was a bit simplified in the process, but no test-semantic changes were made.

revset: include all non-public phases in _notpublic We forgot up to update this when new phases were added.

dirstate: remove _actual_file_name methode This is dead-code

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.

run-tests: fix a crash when using the coverage options 35bf7f23b84c attempted to transition away from `distutils`, but the `packaging` code lacks `StrictVersion`. I have no idea when `packaging.version` became available, but I have it in python 3.6, so that should be good enough. For some reason, the import checker thinks this is a local import, and needs help to decide otherwise. Alternately we could ditch the version check entirely, because `coverage` is currently at 7.2.1, and the original check was added back in 2010.

rust: fix building on macOS (issue6801) The VFS change is copied over from Cargo, and likely to apply to other platforms as well. The dirstate change is essentially a replay of 440972d2175d, which was reverted in e98fd81bb151, part of !383, to silence some clippy warnings.

tests: fix timeout adjustement in delaypush.py Doing integer arithmetic with string is bound to fail.

revlog: add an exception hint when processing LFS flags without the extension It would be even better if this was either detected sooner, or the transaction completed (especially since the read/write processors aren't needed for the exchange). But this makes it easier for the user to resolve until that can be figured out.

tests: drop py36 conditionals in test-bad-extension.t Since this is a `>=` test, it's really conditionalizing py27 content, which isn't a thing anymore.

tests: drop py36 conditionals in test-hook.t Since this is a `>=` test, it's really conditionalizing py27 content, which isn't a thing anymore.

tests: drop py36 conditionals in test-http-bad-server.t Since this is a `>=` test, it's really conditionalizing py27 content, which isn't a thing anymore.

configitems: enable changegroup3 by default (unless using infinitepush) The LFS extension requires this, and if it isn't enabled on the client (or the LFS extension isn't loaded), a web client gets a 500 instead of a sensible error message. Now it gets a different (client) error, but maybe it can be handled more gracefully. c0f11347b107 indicates that treemanifest repos have this issue too. 29cfc474c5fd mentions gating this behind `experimental` so that the format could change, but that was 7 years ago and we now have an experimental `changegroup4` as well. We can keep this as a config for the next cycle in case someone runs into an unexpected problem, and then jettison it if the infinitepush bundle name changes are either acceptable as-is or can be created differently.

infinitepush: opt out of changegroup3 unless explicitly configured This is currently a no-op, as changegroup3 is disabled by default. But when it is enabled, it changes the hash names of the bundle files. As I don't use this extension, I have no idea if that's OK or not. So keep the current default behavior until we can get more info from actual users, while allowing them to opt-in for testing purposes.

statichttprepo: unbyteify several IOError messages Builtin errors generally want str messages.

statichttprepo: fix the vfs.join() method to match the base class definition Flagged by PyCharm. The superclass implementation raised NotImplementedError.

mail: unbyteify the SMTPException message This is a subclass of OSError, which wants str instead of bytes.

mail: add a missing argument to properly override starttls I didn't look into when this changed, but it was flagged by PyCharm.

crecord: switch a curses argument to bool to appease type checkers

grep: avoid reassigning byteskwargs to strkwargs PyCharm flagged each of these `get()` calls with bytes. We still pass the bytes form to the formatter to avoid changing the API, until all callers can be changed.

cat: drop unnecessary internal roundtrip of kwargs PyCharm seems to stick with the type at the initial assignment, so it flagged the `get()` with a bytes key since the method argument has str keys. It wasn't a bug, but then the bytes form is otherwise unused, and converted back to str.

relnotes: add 6.4 and empty next

Added signature for changeset 05de4896508e

Added tag 6.4rc0 for changeset 05de4896508e

branching: merge default into stable

transaction: drive the aberratant branch special case away shoo shoo shoo shoo. Happy to remove this awful special case (that I introduced myself last week…)

transaction: remove the `branch` backup for transaction We can now back it up at the end of the transaction as we do for the rest of the dirstate.

dirstate: deprecate calling `setbranch` without a transaction parameter The new way is now enforced.

branch: pass current transaction when writing branch for transaction backup This will requires more change soon (as we can simplify this backup). This will be done in later changesets.

branch: pass current transaction when writing branch in shelve

branch: pass current transaction when writing branch in import

branch: pass current transaction when writing branch in backout command

branch: pass current transaction when writing branch in branch command

branch: pass current transaction when writing branch in merge

branch: pass current transaction when writing branch in rebase

branch: pass current transaction when writing branch in keyword

branch: pass current transaction when writing branch in histedit

dirstate: write the `branch` as part of the transaction if any Bypassing the transaction means we could get out of sync with the dirstatemap content. The branch is stil written right away if no transaction is around, but at least it no longer bypass the transaction. Actual caller of this still need to be updated.

dirstate: factor the transaction abort logic We will need it in more occasion if the branch is to be written as part of the transaction.

dirstate: use a context manager to handle the file used for writing the branch This is more modern.

style: rewrap `ui.deprecwarn` declaration This get easier to read, especially with the type annotation.

branching: merge stable into default The clippy god had to be appeased on some aspect.

narrow: read pending file when applicable Now that this is part of the transaction, this is necessary to make sure we read the right data in hooks (if any).

Added signature for changeset 8830004967ad

Added tag 6.3.3 for changeset 8830004967ad

relnotes: add 6.3.3

typing: add typehints to mercurial/diffutil.py Lack of typehints here caused the fact that TortoiseHg was passing str instead of bytes as the key in `opts` to be missed, resulting in shelf corruption in cases where `diff.git` is required.

patchbomb: respect the `--git` option I *think* this is the only diffopt exposed on the command line. TortoiseHg had a similar issue creating diffopts, and this was caught by type hints in the next commit.

rhg: remember the inode of .hg/dirstate This allows us to detect changes of `.hg/dirstate`, which is either the full dirstate (in dirstate-v1) or the docket file (v2) without relying on data inside the file. It only works on UNIX systems. This fixes a race condition for dirstate-v1 (as demonstrated by the test changes) and adds a confortable layer of sanity for dirstate-v2.

rust-dirstate-v2: don't write dirstate if data file has changed This fixes the following race: - process A reads the dirstate - process B reads and writes the dirstate - process A writes the dirstate This either resulted in losing what process B had just written or a crash because the `uuid` had changed and we were trying to write to a file that doesn't exist. More explanations inside. This doesn't fix the issue for dirstate-v1, a later patch addresses it.

rust-dirstate: remember the data file uuid dirstate was loaded with This will be used in the next patch to fix a race condition.

dirstate: set identity whenever we read the dirstate's v2 docket The docket can be loaded outside of a full read (for exemple when pre-fetching parents), so the current code would read/set the identity after loading the data, opening a race condition: A0: first process docket is read B0: other process appends new data to the dirstate (and changes the docket) A1: first process sets the identity (based on pre-B content, but with post-B identity) A1: first process loads the dirstatemap from the data file A1: first process does not detect the race and overwrites the update from B.

dirstate: factor the identity setting code in the dirstate map We need it in more locations, so let us start factoring thing out first to make sure the same code is called everywhere. This bears some similarity with 85746485a4dd on default, but at a smaller scope and for a different purpose.

dirstate: simplify the dirstate's read race testing Now that most code behaves properly, we can simplify the expected matching.

dirstate: deal with read-race for pure rust code path (rhg) If we cannot read the dirstate data, this is probably because a writing process wrote it under our feet. So refresh the docket and try again a handful of time.

dirstate: deal with read-race for python code using rust object If we cannot read the dirstate data, this is probably because a writing process wrote it under our feet. So refresh the docket and try again a handful of time.

dirstate: deal with read-race for pure python code If we cannot read the dirstate data, this is probably because a writing process wrote it under our feet. So refresh the docket and try again a handful of time.

dirstate: abstract the reading of the data file in v2 in a method We will need more changes to avoid some race conditions during read, so we first isolate the simple logic before making it more complicated.

dirstate: add append/new-file variants in the dirstate's read race tests This covers more ground and finds more bugs. At that point I gave up on making things as `known-bad-output` / `missing-correct-output` as this gets too messy.

dirstate: add a synchronisation point in the middle of the read This will be useful to test some more race conditions around dirstate.

dirstate: add v1-v2 variants to the dirstate's read race tests More cases mean different issues.