bundle2: first crude version of bundling changeset with bundle2 The current changegroup format is put in a "changegroup" part and processed by an appropriate handlers. This is not production ready code, but let us start smoke testing.

bundle2: record processing results in the bundleoperation object Part handlers can now add records to the `bundleoperation` object. This can be used to help other parts or to let the caller of the unbundling process react to the results.

bundle2: introduce a bundleoperation object This object will hold all data and state gathered through the processing of a bundle. This will allow: - each handler to be aware of the things unbundled so far - the caller to retrieve data about the execution - bear useful object and logic (like repo, transaction) - bear possible bundle2 reply triggered by the unbundling. For now the object is very simple but it will grow at the same time as the bundle2 implementation.

bundle2: feed a unbundle20 to the `processbundle` function The unbundle can comes from multiple sources. (on disk file, peer, etc) and (ultimately) of multiple type (bundle10, bundle20). The `processbundle` is no longer in charge of creating the bundle.

bundle2: lock the repo during unbundle test We forgot the lock the repo. It's not too bad during tests, but the lock also still carry some transaction logic. (yes we need to get rid of this)

merge: keep destination filename as key in filemerge actions Gives more readable debug output and makes it possible to compare/merge actions later.

merge: keep destination filename as key in actions for merge with dir rename Avoids None: local renamed directory to b/c -> d updating:None 1/1 files (100.00%) and makes it possible to compare/merge actions later.

merge: include ancestor node in merge actions

merge with stable

repoview: use _gethiddenblockers in computehidden No functionality has changed, since we've only extracted the code into its own function. Now extensions can wrap _gethiddenblockers to provide their own blocker without polluting bookmarks or local tags.

repoview: add _gethiddenblockers method This is a standalone function that will provide the ability for extensions to wrap.

repoview: improve performance for computehidden (issue4206) For repos with a large number of heads (including hidden heads), a stale tag cache would cause computehidden to be drastically slower because of a the call to repo.tags() (which would build the tag cache). We actually don't need the tag cache for computehidden because we filter out global tags. This patch replaces the call to repo.tags with readlocaltags so as to avoid the tag cache.

tests: remove unused variables from test-pathencode.py caught by pyflakes

shelve: remove unused variable caught by pyflakes

changegroup: remove unused variable caught by pyflakes

hgk: use hg export to write commits Instead of calling internal command, use hg export to produce changeset diffs compatible with hg import directly.

hgk: add .diff extension when exporting commits Append the .diff extension automatically.

localrepo: move the addchangegroup method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo.

localrepo: move the addchangegroupfiles method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had a single caller, far too few for being kept in local repo.

localrepo: move the changegroup method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo. The peer API stay unchanged.

localrepo: move the getbundle method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo. The peer API remains unchanged.

store: drop unused existing list

localrepo: move the getlocalbundle method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had 3 callers total, far too few for being kept in local repo.

localrepo: move the changegroupsubset method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo. The peer API remains unchanged.

localrepo: move the changegroupinfo method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had a single caller... already in this changegroup module.

localrepo: move the _changegroupsubset method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had 3 callers total, far too few for being kept in local repo.

push: pass a `pushoperation` object to localrepo.checkpush The `pushoperation` object contains strictly more data the arguments currently passed to `localrepo.checkpush` we pass the new object instead. This function is used by MQ to abort push that includes MQ changesets. Note: extension that may use this function will have to align.

wireproto: use decorator for the ubundle command

wireproto: use decorator for the stream command

wireproto: use decorator for the pushkey command

wireproto: use decorator for the lookup command

wireproto: use decorator for the listkeys command

wireproto: use decorator for the known command

wireproto: use decorator for the hello command

wireproto: use decorator for the heads command

wireproto: use decorator for the getbundle command

wireproto: use decorator for the debugwireargs command

wireproto: use decorator for the changegroupsubset command

wireproto: use decorator for the changegroup command

wireproto: use decorator for the capabilities command

wireproto: use decorator for the branches command

wireproto: use decorator for the branchmap command

wireproto: use decorator for the between command

wireproto: use decorator for the batch command

wireproto: add decorator for wire protocol command Move move in the same direction we took for command line commands. each wire protocol function will be decorated with its name and arguments. Beside beside easier to read, this open the road to easily adding more metadata (like security level or return type)

wireproto: drop the _decompress method in favor a new call type We already have multiple call function for multiple return type. The `_decompress` function is only used for http and seems like a layer violation. We drop it in favor of a new call type dedicated to "stream that may be useful to compress".

wireproto: document protocol specific function of wirepeer Those function are explicitly declared and documented now.

wireproto: introduce an abstractserverproto class sshserver and webproto now inherit from an abstractserverproto class. This class is introduced for documentation purpose.

wireproto: document possible return type The wireprotocole command use a small set of class as return value. We document the meaning of each of them. AS my knowledge of wire protocol is fairly shallow, the documentation can probably use improvement. But this is a better than nothing.

pull: add a set of steps that remain to be done during the pull With bundle2 we'll slowly move current steps into a single bundle2 building and call (changegroup, phases, obsmarkers, bookmarks). But we need to keep the old methods around for servers that do not support bundle2. So we introduce this set of steps that remains to be done.

pull: put discovery step in its own function The discovery is a full step that will grow to contain more than changesets. We set it in its own function like all other steps.

pull: move the cgresult logic in _pullchangeset Logical follow up of the previous changeset. The `_pullchangeset` is now responsible of setting the `pullop.cgresult`.

pull: move return code in the pull operation object With bundle2 we'll have multiple code path susceptible to be responsible for adding changeset during the pull. We move it to the pull operation to simplify this the coming logic. The one doing the adding the changegroup will set the value.

merge: use ancestor filename from planning phase instead of filectx ancestor test-merge-types.t changes a bit in flag merging. It relied on the implementation detail that 100% identical revlog entries are reused. The revlog reuse did that fctx.ancestor() saw an ancestor where there really not was one.

tests: prevent test-hup from hanging forever if the transaction does not start If the transaction fails to start because of some programing errors, the test would stay stuck in this while loop forever. We now added a basic safeguard that abort the loop if nothing happen in 10 seconds. 10 seconds sounds enough to let the server catch up and open a transaction.

revset: improve roots revset performance Previously we would iterate over every item in the subset, checking if it was in the provided args. This often meant iterating over every rev in the repo. Now we iterate over the args provided, checking if they exist in the subset. On a large repo this brings setting phase boundaries (which use this revset roots(X:: - X::Y)) down from 0.8 seconds to 0.4 seconds. The "roots((tip~100::) - (tip~100::tip))" revset in revsetbenchmarks shows it going from 0.12s to 0.10s, so we should be able to catch regressions here in the future. This actually introduces a regression in 'roots(all())' (0.2s to 0.26s) since we're now using spansets, which are slightly slower to do containment checks on. I believe this trade off is worth it, since it makes the revset O(number of args) instead of O(size of repo).

revset: improve _descendants performance Previously revset._descendants would iterate over the entire subset (which is often the entire repo) and test if each rev was in the descendants list. This is really slow on large repos (3+ seconds). Now we iterate over the descendants and test if they're in the subset. This affects advancing and retracting the phase boundary (3.5 seconds down to 0.8 seconds, which is even faster than it was in 2.9). Also affects commands that move the phase boundary (commit and rebase, presumably). The new revsetbenchmark indicates an improvement from 0.2 to 0.12 seconds. So future revset changes should be able to notice regressions. I removed a bad test. It was recently added and tested '1:: and reverse(all())', which has an amibiguous output direction. Previously it printed in reverse order, because we iterated over the subset (the reverse part). Now it prints in normal order because we iterate over the 1:: . Since the revset itself doesn't imply an order, I removed the test.

revsetbenchmark: remove python 2.7 dependency revsetbenchmark.py used check_output which only exists in python 2.7. This fixes it.

bundle2: read the whole bundle from stream on abort When the bundle processing abort on unknown mandatory parts, we now makes sure all the bundle content is read. This avoid leaving the communication channel in an unrecoverable state.

bundle2: add some distinction between mandatory and advisory part Mandatory part cannot be ignored when unknown. We raise a simple KeyError exception when this happen. This is very early version of this logic, see inline comment for future improvement lead.

bundle2: introduce a `parthandler` decorator Simple syntax sugar to register an handler for a new part type.

bundle2: first version of a bundle processing We now have a function that interpret part content. This is a version early version of this function. It'll see major changes in scope and API in future development. As for previous I'm just focussing on getting minimal logic setup. Refining will happen with real world usage.

bundle2: rename unbundle2 test command to statbundle2 We will introduce object to actually process the bundle, we need to keep the simplistic unbundle around for the test.

bundle2: safely read unpack data from part header We use the same approach that the other unpack, as function is given the struct format and his both responsible for reading the right amount of data from the header and unpack the struct. This give use flexibility if we decide to change the size of something in the format before the release.

transaction: drop extra import caught by pyflakes

fncache: clean up fncache during strips Previously the fncache was cleaned up at read time by noticing when it was out of sync. This caused writes to happen outside the scope of transactions and could have caused race conditions. With this change, we'll keep the fncache up-to-date as we go by removing old entries during repair.strip.

caches: invalidate store caches when lock is taken The fncache was not being properly invalidated each time the lock was taken, so in theory it could contain old data from prior to the caller having the lock. This changes it to be invalidated as soon as the lock is taken (same as all our other caches).

fncache: move fncache writing to be in a transaction Previously the fncache was written at lock.release time. This meant it was not tracked by a transaction, and if an error occurred during the fncache write it would fail to update the fncache, but would not rollback the transaction, resulting in an fncache that was not in sync with the files on disk (which causes verify to fail, and causes streaming clones to not copy all the revlogs). This uses the new transaction backup mechanism to make the fncache transacted. It also moves the fncache from being written at lock.release time, to being written at transaction.close time.

transaction: add support for non-append files This adds support for normal, non-append-only files in transactions. For example, .hg/store/fncache and .hg/store/phaseroots should be written as part of the transaction, but are not append only files. This adds a journal.backupfiles along side the normal journal. This tracks which files have been backed up as part of the transaction. transaction.addbackup() creates a backup of the file (using a hardlink), which is later used to recover in the event of the transaction failing. Using a seperate journal allows the repository to still be used by older versions of Mercurial. A future patch will use this functionality and add tests for it.

transaction: add onclose/onabort hook for pre-close logic Adds an optional onclose parameter to transactions that gets called just before the transaction is committed. This allows things that build up data over the course of the transaction (like the fncache) to commit their data. Also adds onabort. It's not used, but will allow extensions to hook into onclose and onabort to provide transaction support.

clone: put streaming clones in a transaction Streaming clones were writing to files outside of a transaction. Soon the fncache will be written at transaction close time, so we need streaming clones to be in a transaction.

fncache: remove the rewriting logic The fncache could rewrite itself during a read operation if it noticed any entries that were no longer on disk. This was problematic because it caused Mercurial to perform write operations outside the scope of a lock or transaction, which could interefere with any other pending writes. This will be replaced in a future patch by logic that cleans up the fncache as files are deleted during strips.

pull: prevent duplicated entry in `op.pulledsubset` In the bare pull case we could add the same node multiple time to the `pulloperation.pulledsubset`. Beside being a bit wrong this confused the new revset implementation of `revset._revancestor` into giving bad result. This changeset fix the pull operation part. The fix for the revset itself will come in another changeset.

bundle2: part params

bundle2: support for bundling and unbundling payload We add the ability to bundle and unbundle a payload in parts. The payload is the actual binary data of the part. It is used to convey all the applicative data. For now we stick to very simple implementation with all the data fit in single chunk. This open the door to some bundle2 testing usage. This will be improved before bundle2 get used for real. We need to be able to stream the payload in multiple part to exchange any changegroup efficiently. This simple version will do for now. Bundling and unbundling are done in the same changeset because the test for parts is less modular. However, the result is not too complex.

merge with stable

Added signature for changeset 3f83fc5cfe71

Added tag 2.9.2 for changeset 3f83fc5cfe71

backout: correct commit status of no changes made (BC) (issue4190) If backout generated no changes to commit, it showed wrong status, "changeset <target> backs out changeset <target>", and raised TypeError with -v option. This changes the return code to 1, which is the same as "hg commit" and "hg rebase".

backout: document return code of merge conflict

merge with stable

i18n: fix "% inside _()" problems Before this patch, "contrib/check-code.py" can't detect these problems, because the regexp pattern to detect "% inside _()" doesn't suppose the case that format string consists of multiple string components concatenated implicitly or explicitly, This patch does below for that regexp pattern to detect "% inside _()" problems in such case. - put "+" into separator part ("[ \t\n]") for explicit concatenation ("...." + "...." style) - enclose "component and separator" part by "(?:....)+" for concatenation itself ("...." "...." or "...." + "....")

i18n: fix "% inside _()" problems Before this patch, "contrib/check-code.py" can't detect these problems, because the regexp pattern to detect "% inside _()" doesn't suppose the case that the format string and "%" aren't placed in the same line. This patch replaces "\s" in that regexp pattern with "[ \t\n]" to detect "% inside _()" problems in such case. "[\s\n]" can't be used in this purpose, because "\s" is automatically replaced with "[ \t]" by "_preparepats()" and "\s" in "[]" causes nested "[]" unexpectedly.

merge: fix lack of "%s" in format string causing TypeError at runtime

i18n-pt_BR: synchronized with c57c9cece645

i18n-ja: synchronized with e259d4c462b5

bundle2: support unbundling empty part We augment the unbundler to make it able to unbundle the empty part we are now able to bundle.

revset: raise ValueError when calling min or max on empty smartset min([]) raise a ValueError, we do the same thing in smartset.min() and smartset.max() for the sake of consistency. The min/amax test are greatly improved in the process to prevent this familly of regression

revpair: smartset compatibility Since recent revset changes, revrange now return a smartset. This smart set probably does not support indexing (_addset does not). This led to crash. Instead when the smartset is ordered we use the `min` and `max` method of smart set. Otherwise we turn is into a list and use indexing on it. The tests have been updated to catch such regression.

revsetbenchmark: add entry for ::rev:: Revsets of the form ::rev:: were identified as the source behind the regressions in issue 4201. Ensure we have explicit coverage of that revset.

merge with stable This should correct an earlier couple of bad merges (5433856b2558 and 596960a4ad0d, now pruned) that accidentally brought in a change that had been marked obsolete (244ac996a821).

tests: use TESTTMP instead of TESTDIR In 57d0c8c3b947, f042d4b263f4, 1e686e55780c, and 5d22cadd1938, new tests were added that used TESTDIR instead of TESTTMP thereby leading to polluting the working directory with these temporary files. Now, we use TESTTMP so that they will be cleaned up properly.

hg: introduce "wirepeersetupfuncs" to setup wire peer by extensions (issue4109) Since changeset 6f72e7d28b35, "reposetup()" of each extensions is invoked only on repositories enabling corresponded extensions. This causes that largefiles specific interactions between the repository enabling largefiles locally and remote (wire) peer fail, because there is no way to know whether largefiles is enabled on the remote repository behind the wire peer, and largefiles specific "wireproto functions" are not given to any wire peers. To avoid this problem, largefiles should be enabled in wider scope than each repositories (e.g. user-wide "${HOME}/.hgrc"). This patch introduces "wirepeersetupfuncs" to setup wire peer by extensions already enabled. Functions registered into "wirepeersetupfuncs" are invoked for all wire peers. This patch uses plain list instead of "util.hooks" for "wirepeersetupfuncs", because the former allows to control order of function invocation by order of extension enabling: it may be useful for workaround of problems with combination of enabled extensions

templater: raise error for unknown func Previously, if a template '{foo()}' was given, the buildfunc would not be able to match it and hit a code path that would not return so it would error out later in the templater stating that NoneType was not iterable. This patch makes sure that a proper error is raised so that the user can be informed. Tests have been updated.

bundle2: support bundling of empty part (with a type) Here start the work on bundle2 parts. Our first step is to be able to bundle a simplistic part that just have a type, no parameters, empty payload.

revsetbenchmark: add a summary at the end of execution The summary list timing per revset making it much more easier to compare revision to each other.