packaging: bump version to 6.3.0.dev

merge back with stable (post-release)

packaging: bump version to 6.2.1.dev

Added tag 6.2.0 for changeset d4ee0274a8ef

merge back with stable

merge with future 6.2.0 No extra change were needed compared to 3.9.

merge with future 6.2.0 The new 'olog' command is not working with 3.9 so we skill all mentions of it in the tests. This also apply to the topic extensions.

merge with future 6.2.0 Minor unrelated output adjustements were needed.

merge with future 6.2.0 There are been (multiple) minor output changes.

packaging: prepare release 6.2

debian: fix email

topic: update 'tested with' and readme We are compatible with Mercurial 4.0 and above

readme: rearrange readme before release There won't be a bugfix release (and other cleanup)

test: reduce output size to fight unstability Until `hg touch` can be more stable, we have to do this :-/

tests: disable blackbox for 'getid' This will significantly simplify the blackbox log.

compat: handle lack of 'util.timer' for pre 4.2 version We keep compatibility with previous Mercurial version by redefining the timer when needed.

test: enforce color to be enabled 4.2 enable color by default and start to get used in test. So we add this to the test for previous version.

merge with default

tests: add a test about strip with obshashrange enable I've seen some traceback but I cannot reproduce them. This tests seems useful anyway.

obshistory: add a json test with cycles

tests: glob an absolute path The ssh command path was in full and pointing the mercurial checkout of the last one who touched the test.

olog: document the default value We actually display the log for '.' which is useful.

readme: rearrange changelog content blackbox is more important than the various caches changes.

obshistory: rename the command to "olog" The command start to look good enough to be handed out to user. We replace the old and useless "olog" alias in favor of the new command.

obshistory: move the command into the obshistory module The root module is far too large already.

obshistory: add docstring to cmddebugobshistory Add debugobshistory command documentation based on the log command documentation.

obshashrangecache: make sure we re-warm the cache after a reset This will "mitigate" the effect of dropping existing entries when new markers affect existing range.

obshashrangecache: precisely track affected revs when adding new markers This will be useful when we start doing finer grained invalidation (instead of dropping all data).

debugobshistory: handle multiple cycles We previously handled up to one cycle only. This is now fixed.

test: clean the debugobshistory cycle test Use 'desc(...)' instead of revision numbers. Also blank lines between commands in the same test

obsdiscovery: add more debug output we add a summary debug output to help gathering data.

discovery: log information about obshashrange We augment the blackbox output to help with data gathering.

obshistory: add a graph option on the debugobshistory command Add a graph option (--graph) to the debugobshistory. The output is like the 'hg log -G' output. The option is activated by default but can be deactivated with '--no-graph' option. There are various issue with the current implementation (multiple cycles handling, N² complexity) but this can be fixed later.

obshistory: import 'node' as 'nodemod' This simplify the next changeset.

label: add a label for the node in the "wc now at" message MOAR COLOR FOR THE COLOR GOAD!

label: rename 'evolve.short_node' to 'evolve.node' A wider labelk will helps compatibility.

obshistory: refactor debugobshistory Rename the function and extract the heavy work of the command in a separate module named obshistory.py

test: adapt to change in cache warming in core Core Mercurial has a more rational cache warming strategy now. 24f55686a63d stopped warming of the cache after every changegroup application (in favor of end of transaction warming). This reflect in the blackbox test output.

test: adapt to change in cache warming in core Core Mercurial has a more rational cache warming strategy now. 2b6692df1bdf stopped warming of the cache after every commit (in favor of end of transaction warming). This reflect in the blackbox test output.

stablerangecache: avoid crash when 'cache/' directory is missing If the directory is missing, we create it.

obshashrange: avoid crash when 'cache/' directory is missing If the directory is missing, we create it.

tests: apply output changes from core fix Mercurial core fixed a bug were the obsolete set (and all depending data) stayed invalid after markers were merged. Fixing this bug is fixing some bad output on the evolve side so we apply the output change.

packaging: mention 'dev' status in the version number

color: update the shorttemplate to use colors

merge with stable

obshashrange: cleanup 'valid' life cycle - reset is only called when we detect a strip, the on disk data are invalid, - after a reset, we should not keep using the data base connection, - after a write, the on disk data are valid.

obsrangecache: raise programming error when using an unwarmed cache This will provide a better experience for developer using this the cache.

obshashrange: stop marking on-disk data as invalid on clear This was abusing and prevent proper use of the on disk cache.

obshashcache: purge the meta line before writing a new one Otherwise we get multiple lines and this gets messy.

obshashrange: drop spurious whitespace

obshashcache: invalidate affected cache entries on side Calling reset during upgrade is screwing up the cache key update.

obshashcache: properly break out of all loops

dualsourcecache: simplify cachekey.clear We do not needs the super call anymore and we can make the reset case more explicit. So we do.

tests: small test update This is a bit clearer.

dualsourcecache: fix obskey return by _checkkey The function was returning the old key instead of the new one. This is now fixed.

test: update test-obsolete.t to use common.sh The definition of getid() in the test file was wrong, use the one from common.sh instead

obshashrange: log reset from new markers This will help tracking performance impact from current limitation.

dualsourcecache: log cache reset

stablerange: log time spent updating the stable range

cache: track time spend updating various cache This produce more useful blackbox log.

obshashrange: adds blackbox usage in tests This will help track the validation of the cache.

obshashrange: test behavior in case of rollback The cache should be properly invalidated.

obshashrange: extend tests We test more situations.

dualsourcecache: add a cache name This will be used to automatically log message for blackbox

obscache: stop definition of the empty key

obshashrange: keep value fetched from sql in memory This will reduce the number of roundtrip to the data base we need.

obshashrange: stop inheriting from 'dict' A simple dictionary attribute seems more simpler.

merge with stable

obshashrange: to not overwrite the list with the set We reusing the list variable lower in the code.

obshashrange: properly break out of the two loops Otherwise we would continue to iterate even after we reseted the cache.

obshashrange: fix reset conditional If the revision is in "revs" we should not reset the cache. The old code was wrong (Thanks goes to new tests for catching this).

cache: ensure we warm stablerange cache before the obshashrange cache I've been seeing traceback that seems to be happening because of issues in this area.

evolve: fixing obscache invalidation This was missing a call to the parent's destroyed(), such that any transaction after stripping some nodes would result in a crash (by attempting to read nodes which were stripped).

obshashrange: warm the cache at the end of each transaction This will help having warmed cache for read only client. The warming is still imperfect in case of markers that trigger a reset, but we are in a better place than what we used to be.

obshashrange: warm cache outside of loops The performance impact will be lower

obshashrange: "update" the cache on each transaction close Right now the "update" does not really file the cache, but it will detect invalid situation and clean them.

obshashrange: properly invalidate the cache on destroyed Copy paste is the scurge of code source.

obshashrange: properly drop the current connection on clear

obshashrange: exit early if nothing to write

obshashrange: use the dualsourcecache as a base for the cache This will easily open the way to incrementally updated obshashrange cache. Small update are needed to the data base schema so be bump the version Currently the update function is not warming the cache (but details case where it is invalidated).

obscache: makes dualsourcecache compatible with obshashrange cache needs The goal of the abstract method is to be reusable. So we make sure it is reusable.

readme: add a changelog entry about the more efficient obscache

obscache: extract a data agnostic class We now have an independent class that we can reuse for other purpose (eg: obshashrange cache)

obscache: extract the actual data update in a dedicated function This will help extract a data agnostic class.

obscache: move an assert to a lower level

obscache: use 'nullid' as the hash of an empty obsstore This align this result with what we use for 'emptykey'

obcache: move empty on the class We'll extract a smaller data agnostic class but we need to gather all method on it first.

obcache: move _checkkey on the class We'll extract a smaller data agnostic class but we need to gather all method on it first.

obcache: move updateneeded on the class We'll extract a smaller data agnostic class but we need to gather all method on it first.

obshistory: only display each revision once in debugobshistory When using a revision range, the same precursor could have been displayed more than once. Use a cache to display each revision only once. It's a fix until we found the nicest way to display obs history.

obshistory: display a message when one marker node has no change ctx When exchanging obs markers, there is some change contexts referencing change contexts that are not available locally. As we cannot display informations about them, instead print a message saying so.

ui: hg topic now display if current revision is in bad state (issue5533) Previously, hg topic didn't showed the state of the current revision. Now if show both informations.

obsstore: also guard agains changing object in '_checkkey' The 'upgradeneeded' function needs to be able to pass the object it fetched once.

obscache: guard from changing changelog or obsstore object We access these object once to make sure they will never change through the function (and their content will be fixed).

obscache: return the new data along-side the upgrade needs (and cache key) Having one function returning consistent data will help prevent race.

obscache: use the smaller scope function This make the function simpler and allow larger update on the 'upgradeneeded' one.

obscache: extract the cache key validation in its own function This help keep the "up to date logic" simpler and prepare a more complex version of the "upgradeneeded" logic that would return the full data needed for the upgrade.

obshistory: use formatter instead of ui.write in the debugobshistory command Replace ui.write with a formater to have template support and json output. Update tests to assert json outputs.

ui: Fix hg stack json output Previously 'hg stack -Tjson' generated invalid output like: [ { "isentry": true, "topic.stack.desc": "...", "topic.stack.index": 1, "topic.stack.state": "current", "topic.stack.state.symbol": "@" } ] , { "isentry": true, "topic.stack.desc": "...", "topic.stack.index": 1, "topic.stack.state": "current", "topic.stack.state.symbol": "@" }, { "isentry": false, "topic.stack.desc": "...", "topic.stack.state": "base", "topic.stack.state.symbol": "^" } ] I de-indented the fmt.end() to generate this output: [ { "isentry": true, "topic.stack.desc": "...", "topic.stack.index": 1, "topic.stack.state": "current", "topic.stack.state.symbol": "@" }, { "isentry": false, "topic.stack.desc": "...", "topic.stack.state": "base", "topic.stack.state.symbol": "^" } ] I've also added a test case.

topic: configure some default color for topic This makes thg usable

topic: automatically configure thg to display topic If no other config is set, we configure Tortoise-hg to display topic. This should helps usability.

readme: update readme to mention 'debugobshistory'

obshistory: add some color

obshistory: add a debugobshistory command to show obs history of a revs Add the debugobshistory command that accept a revision range and display the obsolescence containing each revision in the range. For the moment, it only displays the predecessors.

tests: add the commit style checker from Mercurial

obscache: update the cache key in place Instead of computing the key in place, we update the existing one using the data used for the incremental update of the content. This will help reaching purely incremental cache eventually. The 'getcachekey' function is dropped as it is no longer used.

obscache: distinct 'clear' and 'reset' We make a difference between basic invalidatiton (or lack of loading) and 'reset' (current cache data are invalid). We can now ensure a non-None key when we start the update. This will allow us to "update" the existing key instead of recomputing one from scratch. This is more efficient and less racy.

merge with stable

serveronly: also enable the obscache for server only setting The obscache is useful and speeds things up. So we also enable for server only setting.

obscache: document a possible way forward to skipping obsstore parsing We document a possibly viable idea for updating the cache on new revs without having to fully parse the obsstore.

obscache: update some documentation Update some data and do some proof reading.

obscache: Only access the new obsmarkers for marker update Since we know what what is the part of the file with "new" markers we can just access these. If the cache was up to date before the transaction, we'll re-parse data we just wrote. See the inline comment for details. This is good enough for now.

obscache: extract _updatemarkers code into its own function This split the update logic from the bit retrieving markers. That cannot be bad.

obscache: extract code to update from new revision Code cleanup and prepare upstreaming. The make the code more likely to work with the key validation returning an iterator of revs to update the cache with.

obscache: move assert earlier in the code If we are to crash, let us crash earlier.

merge back with stable

Added tag 6.1.0 for changeset 8510d3fd7c3b

packaging: prepare version 6.1.0

meta: update tested version to 4.1.2 We tested against the latest 4.1 too.

merge with future 6.1.0 No extra adjustment needed from hg-3.9 result

merge with future 6.1.0 No extra adjustment needed from hg-4.0 result

merge with future 6.1.0 In addition to the output reverted for 4.1, we also drop the "troubles:" entry from the standard log.

merge with future 6.1.0 test pass fine except for the removal of the extra data when accessing hidden revision. The better message are 4.2+ only.

compat: drop the context manager used to write the cache file Mercurial 3.8 does not supports context manager on atomic temporary file.

compat: make obscache code compatible with Mercurial version prior to 4.2 the phasecache.getrevset method is new in 4.2.

evolve: record testing with 4.2 4.2 is now a things and tests pass fine.

merge with default for 6.1.0

packaging first step toward 6.1.0

auto-push: move config help in the extension help That is a better spot than the extension itself.

opening mercurial 4.1 compat branch This branch will receive test update implied by the 4.2 → 4.1 changes.

obscache: skip writing to disk if the data did not changed This will avoid rewriting the cache for every single transaction.

obscache: skip writing if the cache is empty if the cache is empty, we can just skip writing to disk.

obscache: set a valid "empty" cache key if the cache is missing This avoid detecting bad cache when it just happens to be no cache.

obscache: have the obsstore fix empty file cachekey Before this change, the missing file and empty file returned different value.

obscache: log case where the cache is not up to date This will help track performance issue

obscache: still update and use the cache during transaction Other code might access the obsolete set in the middle of a transaction. It is better to use the case in that case since the update will eventually be written when the transaction is committed.

obscache: warm the cache in all cases There are case when the obsstore have been invalidated, but we still need to update the cache.

obscache: update the format to allow negative tiprev If the changelog is empty (but the obsstore is not) the 'tiprev' will be -1.

obscache: load the disk data before checking is the cache is up to date This is actually required since non-loaded cache will never be up to date...

obscache: skip the cache entirely if not up to date The current update code has some race condition windows around updating. But we also ensure the cache are up to date with every transaction. So outdated cache mean another client have been mudding the repository but things will get back in place at the next transaction. So we just skip using the cache when not up to date. This is not the best we could do. But this is good enough for now.

readme: mention that some improvement are enabled for 4.2 only

perf: use the cache to compute the obsolete set. The official "obsolete" computation is switch to using the cache. This provide noticable speed for operation that does not need to actually access the obs markers. The part relating to obsolete changeset computation disappear from the execution profile when it is used.

perf: warm the cache after all transactions This is the simplest way to ensure the data are up to date.

perf: adds a cache to know if obsmarkers might affect a revision Phase information still needs to be thrown in the mix to compute the final information, but skipping reading the obsstore for most operation is a large win. Usage of this cache arrives in the next changeset.

perf: adds cachekey utility to validate changelog+obsstore content We adds more helper about cache key to prepare the arrival of a cache that can be updated iteratively (similar to branchmap cache)

perf: adds some cache key helper on the obsstore class This will be useful to allow validating cache depending on obsstore without parsing the whole obsstore.

compat: only install the better filtered message for mercurial 4.2 and above The helper function does not exist in earlier version.

evolve: update extension help I'm pretty sure there are some missing bits, but this cannot be worse than before.

merge with stable

ui: change the hidden revision error message It now display the same details than the warning when the working directory parent become obsolete like: $ hg update 0 abort: hidden revision '0' (successor: f301a99bd857)! $ hg up 1 abort: hidden revision '1' (pruned)! $ hg update 0 abort: hidden revision '0' (successors: 91311af6da10, 70653776ec4c)!

ui: add better messages when the working copy become obsolete.

topic: directly use "super" call That is how one is supposed to do it.

repo: properly progate "destroyed" call to super class The propagation of the 'destroyed' call was dropped. I'm not certain of the consequences of having a partially broken "destroyed" call, but this can't be good.

safeguard: add an option to disable automatic publishing Pushing to publishing server by mistake is a bit too common in the current state of evolve. Especially when the lack of good feature branch story make the use of -f a bit too common. So we add a very simple experimental option to allow warning (or abort) when changeset are pushed to a publishing server. This is unlikely to survive as is, but this is useful now.

merge back with stable

Added tag 6.0.1 for changeset 5ef112a6eb87

pkg: prepare release 6.0.1

debian: finalize 6.0.0 entry

readme: fix 6.0.0 release date It was March, not February.

merge with future 6.0.1 Nothing special to report

merge with future 6.0.1 Nothing special to report

merge with future 6.0.1 Nothing special to report

checkheads: update tests to match the one in core These test now exists in core, so we update the evolve version.

serveronly: fix reposetup The local 'reposetup' function was shadowing the extension helper one. We add a test for obshashrange using 'serveronly' since this is the item that made use discover the issue.

extension: simplify the extensions helper hierarchy If one mode depends on the other, its extensions helper is merged.

checkheads: do not overwrite code for Mercurial 4.2 and above The fix has been ported to Mercurial core as c6cb21ddf74a.

legacy: fix debugrecordpruneparents to call obsstore.create() with keywords It appears the API was changed twice in Mercurial at - 570f87422f54 "obsstore: add an explicit `date` argument to obsstore.create" - adb3798dce49 "obsstore: add a `parents` argument to obsstore.create" and metadata would be changed to a list of (key, value) pairs. Convert it back to a dict as expected by create().

template: adapt to new showlist() API introduced by hg e5eab0fe69ee

template: pass all mapping data to showlist() Otherwise a keyword depending on repo or ctx couldn't be rendered.

make: merge recipes for help

make: fix indent of ifeq-endif ifeq() can't be a recipe.

tests: update test to match upstreamable version Name have been clarified, documentation has been updated and some test-case have been updated to match the intended test.

tests: fix directory names in exchange-D4 test The test is based on another one and the directory name had not been updated.

tests: fix directory names in exchange-D3 test The test is based on another one and the directory name had not been updated.

merge back with default

Added tag 6.0.0 for changeset 165ad227993d

packaging: prepare version 6.0.0

merged with future 6.0 No output changed.

test-compat-hg-3.9: merge with future 6.0

merge with future 6.0.0

merge with default We are getting close to cutting a 6.0.0

readme: mention the fix for issue4354

checkheads: add a small debug message in case were we give up fast When node is unknown we assume it will stay. Yet, we might have markers to it that are going to be pushed. However, we do not have branch (ancestors) information unless we are very lucky an all of them are pruned. So for now we do not do anything assuming this will be rare. We still add a small debug message to help detecting such situation in the future.

checkheahds: switch algorithm to use pushed markers instead We now checks if markers involved in the push are relevant to nodes in the branch we try to replace. The approach is simpler and more robust. A test showing the limitation of the previous approach is added.

checkheads: add test where the rewrite of the other branch is not direct This will help testing that our logic is properly transitive.

check-heads: add tests about old heads indirectly pruned

checkheads: add more complexe case where a branch is split on multiple ones We extend case A-6 and A-7 with partial counterpart. These case are interesting because some of the partial pushing will (rightfully) works and some other won't.

checkheads: add a test of partially pushing a branch spread on multiple other If a branch is fully obsolete but is result are spread on multiple branch, pushing only one of them should detect we create new branches.

checkheads-tests: add missing parents recording for prune markers It is a bit too easy to forget about theses :/ If they are missing, the markers are not going to be exchanged on push.

checkheads: add some extra tests about "partial push" This adds a couple of test that checks that the head replacement code is properly ignored replacement not relevant to the push.

checkheads: handle partial obsolescence We now properly detects situations were only parts of the remote branch is obsoleted. To do so, we process children in the branch recursively to see if they will be obsolete. The current code has some trouble when the remote branch in unknown locally, or when the prune happened on a successors that is not relevant to the push. These case will be handled later. The processing code is becoming more and more complex, a lighter approach would be to check for the obsolescence markers that are relevant to the pushed set, but I prefer to stick with the current approach until more test cases are written.

test: force a push in inhibit's test Our checkheads detection code is becoming better and will prevent that push. As we do not care about this for inhibit, we simply force the push.

checkheads: basic handling of pruned heads (and associated tests) We now detect that heads was pruned and stop warning about it. Note that this has the same shortcoming as the existing code and only looks at the heads.

checkheads: give up on processing locally unknown changeset There are too many issue with locally unknown changesets, we ignore them for now while we get the core feature of the detection working.

checkheads: import our own copy of the checkheads code I expect enough change and experimental will be made that is it worthwhile having them done in evolution close to the rest of the exchange tests make sense.

compat: work around some filecache bug in 3.8 We are still compatible with this version.

obshashrange: have an half descent wireprotocol command The previous implementation was extremely hacky. The new version is based on the other discovery function and work!

obshashrange: improve message issued during discovery This is a minor new message that help to understand what is going on.

obshashrange: introduce basic sqlite caching Same as for stablerange, this is far from perfect but already a win. The cache is currently extremely volatile, but that will still be a win when doing multiple consecutive request during discovery. Better cache invalidation will happens "in the future".

stablerange: warm cache before using it server side We make sure the cache is fully up to date before starting to use it. Updating all value is more efficient and this give us a single point where we update and write on disk. Hopefully the cache have been kept up to date as we go anyway.

stablerange: warm cache before using it in findrangemissing We make sure the cache is fully up to date before starting to use it. Updating all value is more efficient and this give us a single point where we update and write on disk. Hopefully the cache have been kept up to date as we go anyway.

stablerange: warm cache on transaction (if obshashrange is enabled) If we plan to use it (obshashrange is enabled) we better keep it up to date. If a transaction adds node, we update the cache (this should also update the on disk version).

stablerange: introduce ondisk caching through sqlite There is many short cut and limitation with this first version of a cache but this allow use to envision some actual usage of the stablerange thingy so let us got for it.

stablerange: drop the cache on 'destroyed' if the repository have been strip, the cache is not usable as is. We could be smarter in the invalidation but that is a prototype anyway. G: changed hgext3rd/evolve/stablerange.py

stablerange: support loading the cache iteratively We record how far we loaded so that we can resume from this point.

stablerange: add some basic documentation about the cache

stablerange: warmup all upto a revision Let us start doing more systemic warming of the cache before we start writing things out. This prepare on disk caching.

debugstablerange: add a --verify flag to the command This should help us finding bugs.

stablerange: add a proper debugstablerange commands This commands allows to inspect the standard stable range of a range. That should come handy.

debugobshashrange: add a --subranges option We stop displaying -everything- by default, since is is usually very large. This will help getting better timing when measuring cache effect too, since we won't need to dig out deep cache value that real life usage would not touch.

debug: rename 'debugstablerange' to 'debugobshashrange' The command is more about the 'obshashrange' computation.

debugstablerange: improve output spacing On repo with a descent amount of changeset the number where overflowing in all directions. We give use more room now.

subranges: add a utility function to set the cache This is preparing on disk persistence for the value in this cache.

subranges: add a utility function to access the cache This is preparing on disk persistence for the value in this cache.

depth: add a utility function to set the cache This is preparing on disk persistence for the value in this cache.

depth: add a utility function to access the cache This is preparing on disk persistence for the value in this cache.

stablerange: add warming of the subrange Note that this means we build standard stable subrange for all changesets in the repository this is significantly more than what we were computing before and result is significantly more ranges being computed.

stablerange: fix merge slicing when range has multiple roots The first element in the bottom set is not necessarly the one with the lowest revision. We now properly compute and use the minimum value.

stablerange: small style fix

merge-slicing: introduce and use "inheritance point" for merge The first part of the stable sorted list of revision of a merge will shared with the one of others. This means we can reuse subranges computed from that point to compute some of the subranges from the merge. That point is latest point in the stable sorted list where the depth of the revisions match its index (that means all revision earlier in the stable sorted list are its ancestors, no dangling unrelated branches exists). This is a bit expensive to find since we have to walk all the revision, but being able to reuse subranges in all case (not just regular changesets) provide a massive speedup so the cost is worth it.

stablerange: rearrange the code picking subrange to warm Same logic, as the previous changesets, we prepare the code before adding merge support.

stablerange: rearrange the reusing logic to prepare to merge We'll soon be able to reuse some lower range when dealing with merge too. So we prepare the code for this in advance for clarity.

merge-slicing: explain an alternative implementation in a comments It has a better time complexity so a C implementation would likely out perform the current implementation

merge-slicing: use reachable roots to filter the various branches Reachable roots does what we want and have a quite fast C implementation.