Mercurial > hg
view tests/test-merge-remove.t @ 39638:d292328e0143
exchangev2: fetch manifest revisions
Now that the server has support for retrieving manifest data, we can
implement the client bits to call it.
We teach the changeset fetching code to capture the manifest revisions
that are encountered on incoming changesets. We then feed this into a
new function which filters out known manifests and then batches up
manifest data requests to the server.
This is different from the previous wire protocol in a few notable
ways.
First, the client fetches manifest data separately and explicitly.
Before, we'd ask the server for data pertaining to some changesets
(via a "getbundle" command) and manifests (and files) would be sent
automatically. Providing an API for looking up just manifest data
separately gives clients much more flexibility for manifest management.
For example, a client may choose to only fetch manifest data on demand
instead of prefetching it (i.e. partial clone).
Second, we send N commands to the server for manifest retrieval instead
of 1. This property has a few nice side-effects. One is that the
deterministic nature of the requests lends itself to server-side
caching. For example, say the remote has 50,000 manifests. If the
server is configured to cache responses, each time a new commit
arrives, you will have a cache miss and need to regenerate all outgoing
data. But if you makes N requests requesting 10,000 manifests each,
a new commit will still yield cache hits on the initial, unchanged
manifest batches/requests.
A derived benefit from these properties is that resumable clone is
conceptually simpler to implement. When making a monolithic request
for all of the repository data, recovering from an interrupted clone
is hard because the server was in the driver's seat and was maintaining
state about all the data that needed transferred. With the client
driving fetching, the client can persist the set of unfetched entities
and retry/resume a fetch if something goes wrong. Or we can fetch all
data N changesets at a time and slowly build up a repository. This
approach is drastically easier to implement when we have server APIs
exposing low-level repository primitives (such as manifests and files).
We don't yet support tree manifests. But it should be possible to
implement that with the existing wire protocol command.
Differential Revision: https://phab.mercurial-scm.org/D4489
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Wed, 05 Sep 2018 09:09:57 -0700 |
parents | cb70501d8b71 |
children | 7e99b02768ef |
line wrap: on
line source
$ hg init $ echo foo > foo $ echo bar > bar $ hg ci -qAm 'add foo bar' $ echo foo2 >> foo $ echo bleh > bar $ hg ci -m 'change foo bar' $ hg up -qC 0 $ hg mv foo foo1 $ echo foo1 > foo1 $ hg cat foo >> foo1 $ hg ci -m 'mv foo foo1' created new head $ hg merge merging foo1 and foo to foo1 1 files updated, 1 files merged, 0 files removed, 0 files unresolved (branch merge, don't forget to commit) $ hg debugstate --nodates m 0 -2 unset bar m 0 -2 unset foo1 copy: foo -> foo1 $ hg st -q M bar M foo1 Removing foo1 and bar: $ cp foo1 F $ cp bar B $ hg rm -f foo1 bar $ hg debugstate --nodates r 0 -1 set bar r 0 -1 set foo1 copy: foo -> foo1 $ hg st -qC R bar R foo1 Re-adding foo1 and bar: $ cp F foo1 $ cp B bar $ hg add -v foo1 bar adding bar adding foo1 $ hg debugstate --nodates n 0 -2 unset bar n 0 -2 unset foo1 copy: foo -> foo1 $ hg st -qC M bar M foo1 foo Reverting foo1 and bar: $ hg revert -vr . foo1 bar saving current version of bar as bar.orig saving current version of foo1 as foo1.orig reverting bar reverting foo1 $ hg debugstate --nodates n 0 -2 unset bar n 0 -2 unset foo1 copy: foo -> foo1 $ hg st -qC M bar M foo1 foo $ hg diff Merge should not overwrite local file that is untracked after remove $ rm * $ hg up -qC $ hg rm bar $ hg ci -m 'remove bar' $ echo 'memories of buried pirate treasure' > bar $ hg merge bar: untracked file differs abort: untracked files in working directory differ from files in requested revision [255] $ cat bar memories of buried pirate treasure Those who use force will lose $ hg merge -f file 'bar' was deleted in local [working copy] but was modified in other [merge rev]. What do you want to do? use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u merging foo1 and foo to foo1 0 files updated, 1 files merged, 0 files removed, 1 files unresolved use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon [1] $ cat bar bleh $ hg st M bar M foo1