This is an archive of the discontinued Mercurial Phabricator instance.

Differential D358

copytrace: move fb extension to core under flag experimental.fastcopytrace
AbandonedPublic

Authored by pulkit on Aug 11 2017, 7:26 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

The default copytrace implementation is very slow as it finds all the new files
that were added from merge base up to the head commit and for each file it
checks whether it this was copied or moved version of a different file.

copytrace extension in fb-hgext has a heuristic implementation of copy tracing
which is faster than the current copy tracing. The heuristic limits the search
of copies to just files that are either:

  1. Renames in the same directory
  2. Moved to other directory with same name

Stash@fb did analysis for the above heuristics and found that among 2,443,768
moves/copies there are only 32,234 moves/copies which does not fall under the
above heuristics which is approx. 0.013 of total copies.

If experimental.disablecopytrace = yes, then experimental.fastcopytrace flag
won't be considered as user explcitly disabled copytracing.

Elif experimental.disablecopytrace = no, then experimental.fastcopytrace flag will
be considered and if it's set to true, then the fastcopytrace heuristic
implementation will be used.

There are two more flags added by the implementation:

  1. experimental.fastcopytrace.sourcecommitlimmit

This flag limits the number of commits to be traveresed for the heuristics in
source branch i.e. the branch that is rebased or merged. copytracing can be
slow if there are too many commits in the source branch, so this flag can help
in limiting the number of commits.

  1. experimental.fastcopytrace.maxmovescandidatestocheck

This flag limits the number of heuristically found move candidates to check.

The extension also supports fast copytracing during amends which will be moved
in further patches.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

pulkit created this revision.Aug 11 2017, 7:26 PM
pulkit added a comment.Aug 11 2017, 7:30 PM

Again I am not sure whether the flag names are good. Since disablecopytrace was in experimental section, I went with the same for these ones.

pulkit edited the summary of this revision. (Show Details)Aug 15 2017, 3:44 PM
pulkit updated this revision to Diff 943.
pulkit added a comment.Aug 19 2017, 7:16 PM

Any updates on this? The function _fastmergecopies() is simply a port of _domergecopies() from fbhgext/copytrace.py. https://phab.mercurial-scm.org/diffusion/FBHGX/browse/default/hgext3rd/copytrace.py;75cfcc6fc62a4f172857beebda6c0e43f318ea87$290

quark added subscribers: stash, quark.Aug 20 2017, 4:49 PM

For config options, I think it's cleaner if we can unify them:

experimental.copytrace = disable | default | fast
  • disable: no copy tracing
  • default: old copy tracing algorithm
  • fast: this algorithm

I'm fine with leaving fastcopytrace.sourcecommitlimit config options. But if we do want to not introduce them, they could be also folded into experimental.copytrace option, like fast:sourcecommitlimit=100,maxmovescandidatestocheck=200.

mercurial/copies.py
711–716

This is also used elsewhere. I think it's worthwhile to be defined in localrepository class.

cc @stash Maybe it's more accurate to check paths.default first and fallback to origroot. If a user clones ssh://x/repo-x to repo-x-2, we probably want repo-x as the repo name. What do you think?

quark added inline comments.Aug 20 2017, 4:51 PM
tests/test-fastcopytrace.t
1–9

nit: could execute the script directly

$ initclient() {
>   cat >> $1/.hg/hgrc << EOF
> ...
> EOF
> }
pulkit added a comment.Aug 21 2017, 7:23 AM
In D358#7173, @quark wrote:

For config options, I think it's cleaner if we can unify them:

experimental.copytrace = disable | default | fast
  • disable: no copy tracing
  • default: old copy tracing algorithm
  • fast: this algorithm

I'm fine with leaving fastcopytrace.sourcecommitlimit config options. But if we do want to not introduce them, they could be also folded into experimental.copytrace option, like fast:sourcecommitlimit=100,maxmovescandidatestocheck=200.

I like the idea of unifying the config, but I was thinking to add a copytrace section as there are couple of more flags introduced by copytracing during amend namely amendcopytrace and amendcopytracelimit. (This is when if we don't want to leave sourcecommitlimit and maxmovescandidatestocheck options).
If we don't want to introduce these limiting flags, then we can plug the existing things into experimental section only.

Also after this and copytracing while amend patches (not send yet) get in, I am thinking to have hg help -k copytrace to document these things so that user can understand them.

stash added a comment.Aug 21 2017, 1:34 PM

Quick heads-up: one of our bootcampers works on the task that does the following: if rebase/merge/graft happens only on the local stack (i.e. base commit is draft), then we fallback to the normal copytrace, because we are sure it's going to be fast enough

pulkit abandoned this revision.Aug 23 2017, 2:30 PM

There is work ongoing on improving copytrace in fb-hgext. I will resend patches with updated copytrace logic once the work is done.

Revision Contents
Changeset List

PathPackages
Mmercurial/configitems.py (9 lines)
Mmercurial/copies.py (127 lines)
AMtests/test-fastcopytrace.t (595 lines)

Diff 943

mercurial/configitems.py

default=list, default=list,
) )
coreconfigitem('experimental', 'extendedheader.index', coreconfigitem('experimental', 'extendedheader.index',
default=None, default=None,
) )
coreconfigitem('experimental', 'extendedheader.similarity', coreconfigitem('experimental', 'extendedheader.similarity',
default=False, default=False,
) )
coreconfigitem('experimental', 'fastcopytrace',
default=False,
)
coreconfigitem('experimental', 'fastcopytrace.sourcecommitlimit',
default=100,
)
coreconfigitem('experimental', 'fastcopytrace.maxmovescandidatestocheck',
default=5,
)
coreconfigitem('experimental', 'format.compression', coreconfigitem('experimental', 'format.compression',
default='zlib', default='zlib',
) )
coreconfigitem('experimental', 'graphshorten', coreconfigitem('experimental', 'graphshorten',
default=False, default=False,
) )
coreconfigitem('experimental', 'hook-track-tags', coreconfigitem('experimental', 'hook-track-tags',
default=False, default=False,

mercurial/copies.py

# copies.py - copy detection for Mercurial # copies.py - copy detection for Mercurial
# #
# Copyright 2008 Matt Mackall <mpm@selenic.com> # Copyright 2008 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import collections
import heapq import heapq
import os
from . import ( from . import (
node, node,
pathutil, pathutil,
scmutil, scmutil,
util, util,
) )
defaultdict = collections.defaultdict
def _findlimit(repo, a, b): def _findlimit(repo, a, b):
""" """
Find the last revision that needs to be checked to ensure that a full Find the last revision that needs to be checked to ensure that a full
transitive closure for file copies can be properly calculated. transitive closure for file copies can be properly calculated.
Generally, this means finding the earliest revision number that's an Generally, this means finding the earliest revision number that's an
ancestor of a or b but not both, except when a or b is a direct descendent ancestor of a or b but not both, except when a or b is a direct descendent
of the other, in which case we can return the minimum revnum of a and b. of the other, in which case we can return the minimum revnum of a and b.
None if no such revision exists. None if no such revision exists.
return repo.dirstate.copies(), {}, {}, {}, {} return repo.dirstate.copies(), {}, {}, {}, {}
# Copy trace disabling is explicitly below the node == p1 logic above # Copy trace disabling is explicitly below the node == p1 logic above
# because the logic above is required for a simple copy to be kept across a # because the logic above is required for a simple copy to be kept across a
# rebase. # rebase.
if repo.ui.configbool('experimental', 'disablecopytrace'): if repo.ui.configbool('experimental', 'disablecopytrace'):
return {}, {}, {}, {}, {} return {}, {}, {}, {}, {}
# Switch to fast copy tracing heuristic algorithm if fastcopytrace is
# enabled and user has not explicitly disabled copytracing.
# Also there are cases when _fastmergecopies decided to switch back to
# mergecopies, in that case we are setting an internal config,
# debug.fastcopytrace = no.
override = repo.ui.configbool('debug', 'fastcopytrace', True)
if repo.ui.configbool('experimental', 'fastcopytrace') and override:
repo.ui.debug('swicthing to fast copytracing\n')
return _fastmergecopies(repo, c1, c2, base)
# setting debug.fastcopytrace=yes for next function calls.
repo.ui.setconfig('debug', 'fastcopytrace', 'yes', 'default')
# In certain scenarios (e.g. graft, update or rebase), base can be # In certain scenarios (e.g. graft, update or rebase), base can be
# overridden We still need to know a real common ancestor in this case We # overridden We still need to know a real common ancestor in this case We
# can't just compute _c1.ancestor(_c2) and compare it to ca, because there # can't just compute _c1.ancestor(_c2) and compare it to ca, because there
# can be multiple common ancestors, e.g. in case of bidmerge. Because our # can be multiple common ancestors, e.g. in case of bidmerge. Because our
# caller may not know if the revision passed in lieu of the CA is a genuine # caller may not know if the revision passed in lieu of the CA is a genuine
# common ancestor or not without explicitly checking it, it's better to # common ancestor or not without explicitly checking it, it's better to
# determine that here. # determine that here.
# #
if df not in copy: if df not in copy:
movewithdir[f] = df movewithdir[f] = df
repo.ui.debug((" pending file src: '%s' -> " repo.ui.debug((" pending file src: '%s' -> "
"dst: '%s'\n") % (f, df)) "dst: '%s'\n") % (f, df))
break break
return copy, movewithdir, diverge, renamedelete, dirmove return copy, movewithdir, diverge, renamedelete, dirmove
def _fastmergecopies(repo, cdst, csrc, base):
""" Fast copytracing using filename heuristics
The default copytracing algorithm is very much slow and developers who have
disabled copytracing run into annoying merge issues. So this is a fast
copytracing algorithm using filename heuristics.
The heuristics assumes that most of the renames and copies are either of the
following:
1) Renames in the same directory
2) Moved to the other directory with same name
i.e. the move source and move destination have either the same basename or
same dirname.
Handle one case where we assume there are no merge commits in
"source branch". Source branch is commits from base up to csrc not
including base.
If these assumptions don't hold then we fallback to the mergecopies().
"""
if cdst.rev() is None:
cdst = cdst.p1()
if csrc.rev() is None:
csrc = csrc.p1()
copies = {}
ctx = csrc
changedfiles = set()
sourcecommitnum = 0
sourcecommitlimit = repo.ui.configint('experimental',
'fastcopytrace.sourcecommitlimit')
mdst = cdst.manifest()
while ctx != base:
if len(ctx.parents()) == 2:
# To keep things simple let's not handle merges
repo.ui.debug('merges involved, swicthing back to mergecopies\n')
repo.ui.setconfig('debug', 'fastcopytrace',
'no', '_fastmergecopies')
return mergecopies(repo, cdst, csrc, base)
changedfiles.update(ctx.files())
ctx = ctx.p1()
sourcecommitnum += 1
if sourcecommitnum > sourcecommitlimit:
repo.ui.debug('sourecommitlimit is small, switching back to '
'mergecopies\n')
repo.ui.setconfig('debug', 'fastcopytrace',
'no', '_fastmergecopies')
return mergecopies(repo, cdst, csrc, base)
cp = _forwardcopies(base, csrc)
for dst, src in cp.iteritems():
if src in mdst:
copies[dst] = src
# file is missing if it isn't present in the destination, but is present in
# the base and present in the source.
# Presence in the base is important to exclude added files, presence in the
# source is important to exclude removed files.
missingfiles = filter(lambda f: f not in mdst and f in base and f in csrc,
changedfiles)
if missingfiles:
# Use the following file name heuristic to find moves: moves are
# usually either directory moves or renames of the files in the
# same directory. That means that we can look for the files in dstc
# with either the same basename or the same dirname.
basenametofilename = defaultdict(list)
dirnametofilename = defaultdict(list)
for f in mdst.filesnotin(base.manifest()):
basename = os.path.basename(f)
dirname = os.path.dirname(f)
basenametofilename[basename].append(f)
dirnametofilename[dirname].append(f)
maxmovecandidatestocheck = repo.ui.configint(
'experimental', 'fastcopytrace.maxmovescandidatestocheck')
# in case of a rebase/graft, base may not be a common ancestor
anc = cdst.ancestor(csrc)
for f in missingfiles:
basename = os.path.basename(f)
dirname = os.path.dirname(f)
samebasename = basenametofilename[basename]
samedirname = dirnametofilename[dirname]
movecandidates = samebasename + samedirname
# f is guaranteed to be present in csrc, that's why
# csrc.filectx(f) won't fail
f2 = csrc.filectx(f)
for candidate in movecandidates[:maxmovecandidatestocheck]:
f1 = cdst.filectx(candidate)
if _related(f1, f2, anc.rev()):
# if there are a few related copies then we'll merge
# changes into all of them. This matches the behaviour
# of upstream copytracing
copies[candidate] = f
if len(movecandidates) > maxmovecandidatestocheck:
msg = "too many moves candidates: %d" % len(movecandidates)
repo.ui.log("copytrace", msg=msg,
reponame=_getreponame(repo, repo.ui))
return copies, {}, {}, {}, {}
def _getreponame(repo, ui):
reporoot = repo.origroot if util.safehasattr(repo, 'origroot') else ''
reponame = ui.config('paths', 'default') or reporoot
if reponame:
reponame = os.path.basename(reponame)
return reponame
quarkUnsubmitted
Not Done

This is also used elsewhere. I think it's worthwhile to be defined in localrepository class.

cc @stash Maybe it's more accurate to check paths.default first and fallback to origroot. If a user clones ssh://x/repo-x to repo-x-2, we probably want repo-x as the repo name. What do you think?

quark: This is also used elsewhere. I think it's worthwhile to be defined in `localrepository` class.
def _related(f1, f2, limit): def _related(f1, f2, limit):
"""return True if f1 and f2 filectx have a common ancestor """return True if f1 and f2 filectx have a common ancestor
Walk back to common ancestor to see if the two files originate Walk back to common ancestor to see if the two files originate
from the same file. Since workingfilectx's rev() is None it messes from the same file. Since workingfilectx's rev() is None it messes
up the integer comparison logic, hence the pre-step check for up the integer comparison logic, hence the pre-step check for
None (f1 and f2 can only be workingfilectx's initially). None (f1 and f2 can only be workingfilectx's initially).
""" """

tests/test-fastcopytrace.t

  • This file was added.
$ cat >> $TESTTMP/copytrace.sh << '__EOF__'
> initclient() {
> cat >> $1/.hg/hgrc <<EOF
> [experimental]
> fastcopytrace = True
> EOF
> }
> __EOF__
$ . "$TESTTMP/copytrace.sh"
quarkUnsubmitted
Not Done

nit: could execute the script directly

$ initclient() {
>   cat >> $1/.hg/hgrc << EOF
> ...
> EOF
> }
quark: nit: could execute the script directly $ initclient() { > cat >> $1/.hg/hgrc << EOF > .
$ cat >> $HGRCPATH << EOF
> [extensions]
> rebase=
> shelve=
> EOF
Check filename heuristics (same dirname and same basename)
$ hg init server
$ cd server
$ echo a > a
$ mkdir dir
$ echo a > dir/file.txt
$ hg addremove
adding a
adding dir/file.txt
$ hg ci -m initial
$ hg mv a b
$ hg mv -q dir dir2
$ hg ci -m 'mv a b, mv dir/ dir2/'
$ cd ..
$ hg clone -q server repo
$ initclient repo
$ cd repo
$ hg up -q 0
$ echo b > a
$ echo b > dir/file.txt
$ hg ci -qm 'mod a, mod dir/file.txt'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 557f403c0afd2a3cf15d7e2fb1f1001a8b85e081
| desc: mod a, mod dir/file.txt, phase: draft
| o changeset: 928d74bc9110681920854d845c06959f6dfc9547
|/ desc: mv a b, mv dir/ dir2/, phase: public
o changeset: 3c482b16e54596fed340d05ffaf155f156cda7ee
desc: initial, phase: public
$ hg rebase -s . -d 1
rebasing 2:557f403c0afd "mod a, mod dir/file.txt" (tip)
merging b and a to b
merging dir2/file.txt and dir/file.txt to dir2/file.txt
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/557f403c0afd-9926eeff-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Make sure filename heuristics do not when they are not related
$ hg init server
$ cd server
$ echo 'somecontent' > a
$ hg add a
$ hg ci -m initial
$ hg rm a
$ echo 'completelydifferentcontext' > b
$ hg add b
$ hg ci -m 'rm a, add b'
$ cd ..
$ hg clone -q server repo
$ initclient repo
$ cd repo
$ hg up -q 0
$ printf 'somecontent\nmoarcontent' > a
$ hg ci -qm 'mode a'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: d526312210b9e8f795d576a77dc643796384d86e
| desc: mode a, phase: draft
| o changeset: 46985f76c7e5e5123433527f5c8526806145650b
|/ desc: rm a, add b, phase: public
o changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
desc: initial, phase: public
$ hg rebase -s . -d 1
rebasing 2:d526312210b9 "mode a" (tip)
other [source] changed a which local [dest] deleted
use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
unresolved conflicts (see hg resolve, then hg rebase --continue)
[1]
$ cd ..
$ rm -rf server
$ rm -rf repo
Test when lca didn't modified the file that was moved
$ hg init server
$ cd server
$ echo 'somecontent' > a
$ hg add a
$ hg ci -m initial
$ echo c > c
$ hg add c
$ hg ci -m randomcommit
$ hg mv a b
$ hg ci -m 'mv a b'
$ cd ..
$ hg clone -q server repo
$ initclient repo
$ cd repo
$ hg up -q 1
$ echo b > a
$ hg ci -qm 'mod a'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 9d5cf99c3d9f8e8b05ba55421f7f56530cfcf3bc
| desc: mod a, phase: draft
| o changeset: d760186dd240fc47b91eb9f0b58b0002aaeef95d
|/ desc: mv a b, phase: public
o changeset: 48e1b6ba639d5d7fb313fa7989eebabf99c9eb83
| desc: randomcommit, phase: public
o changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
desc: initial, phase: public
$ hg rebase -s . -d 2
rebasing 3:9d5cf99c3d9f "mod a" (tip)
merging b and a to b
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/9d5cf99c3d9f-f02358cc-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Rebase "backwards"
$ hg init server
$ cd server
$ echo 'somecontent' > a
$ hg add a
$ hg ci -m initial
$ echo c > c
$ hg add c
$ hg ci -m randomcommit
$ hg mv a b
$ hg ci -m 'mv a b'
$ cd ..
$ hg clone -q server repo
$ initclient repo
$ cd repo
$ hg up -q 2
$ echo b > b
$ hg ci -qm 'mod b'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: fbe97126b3969056795c462a67d93faf13e4d298
| desc: mod b, phase: draft
o changeset: d760186dd240fc47b91eb9f0b58b0002aaeef95d
| desc: mv a b, phase: public
o changeset: 48e1b6ba639d5d7fb313fa7989eebabf99c9eb83
| desc: randomcommit, phase: public
o changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
desc: initial, phase: public
$ hg rebase -s . -d 0
rebasing 3:fbe97126b396 "mod b" (tip)
merging a and b to a
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/fbe97126b396-cf5452a1-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Rebase draft commit on top of draft commit
$ hg init repo
$ initclient repo
$ cd repo
$ echo 'somecontent' > a
$ hg add a
$ hg ci -m initial
$ hg mv a b
$ hg ci -m 'mv a b'
$ hg up -q ".^"
$ echo b > a
$ hg ci -qm 'mod a'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 5268f05aa1684cfb5741e9eb05eddcc1c5ee7508
| desc: mod a, phase: draft
| o changeset: 542cb58df733ee48fa74729bd2cdb94c9310d362
|/ desc: mv a b, phase: draft
o changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
desc: initial, phase: draft
$ hg rebase -s . -d 1
rebasing 2:5268f05aa168 "mod a" (tip)
merging b and a to b
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/5268f05aa168-284f6515-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Check a few potential move candidates
$ hg init repo
$ initclient repo
$ cd repo
$ mkdir dir
$ echo a > dir/a
$ hg add dir/a
$ hg ci -qm initial
$ hg mv dir/a dir/b
$ hg ci -qm 'mv dir/a dir/b'
$ mkdir dir2
$ echo b > dir2/a
$ hg add dir2/a
$ hg ci -qm 'create dir2/a'
$ hg up -q 0
$ echo b > dir/a
$ hg ci -qm 'mod dir/a'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 6b2f4cece40fd320f41229f23821256ffc08efea
| desc: mod dir/a, phase: draft
| o changeset: 4494bf7efd2e0dfdd388e767fb913a8a3731e3fa
| | desc: create dir2/a, phase: draft
| o changeset: b1784dfab6ea6bfafeb11c0ac50a2981b0fe6ade
|/ desc: mv dir/a dir/b, phase: draft
o changeset: 36859b8907c513a3a87ae34ba5b1e7eea8c20944
desc: initial, phase: draft
$ hg rebase -s . -d 2
rebasing 3:6b2f4cece40f "mod dir/a" (tip)
merging dir/b and dir/a to dir/b
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/6b2f4cece40f-503efe60-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Move file in one branch and delete it in another
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ hg mv a b
$ hg ci -m 'mv a b'
$ hg up -q ".^"
$ hg rm a
$ hg ci -m 'del a'
created new head
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 7d61ee3b1e48577891a072024968428ba465c47b
| desc: del a, phase: draft
| o changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
|/ desc: mv a b, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg rebase -s 1 -d 2
rebasing 1:472e38d57782 "mv a b"
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/472e38d57782-17d50e29-rebase.hg (glob)
$ hg up -q c492ed3c7e35dcd1dc938053b8adf56e2cfbd062
$ ls
b
$ cd ..
$ rm -rf server
$ rm -rf repo
Too many move candidates
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ hg rm a
$ echo a > b
$ echo a > c
$ echo a > d
$ echo a > e
$ echo a > f
$ echo a > g
$ hg add b
$ hg add c
$ hg add d
$ hg add e
$ hg add f
$ hg add g
$ hg ci -m 'rm a, add many files'
$ hg up -q ".^"
$ echo b > a
$ hg ci -m 'mod a'
created new head
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
| desc: mod a, phase: draft
| o changeset: d133babe0b735059c360d36b4b47200cdd6bcef5
|/ desc: rm a, add many files, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg rebase -s 2 -d 1
rebasing 2:ef716627c70b "mod a" (tip)
other [source] changed a which local [dest] deleted
use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
unresolved conflicts (see hg resolve, then hg rebase --continue)
[1]
$ cd ..
$ rm -rf server
$ rm -rf repo
Move a directory in draft branch
$ hg init repo
$ initclient repo
$ cd repo
$ mkdir dir
$ echo a > dir/a
$ hg add dir/a
$ hg ci -qm initial
$ echo b > dir/a
$ hg ci -qm 'mod dir/a'
$ hg up -q ".^"
$ hg mv -q dir/ dir2
$ hg ci -qm 'mv dir/ dir2/'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: a33d80b6e352591dfd82784e1ad6cdd86b25a239
| desc: mv dir/ dir2/, phase: draft
| o changeset: 6b2f4cece40fd320f41229f23821256ffc08efea
|/ desc: mod dir/a, phase: draft
o changeset: 36859b8907c513a3a87ae34ba5b1e7eea8c20944
desc: initial, phase: draft
$ hg rebase -s . -d 1
rebasing 2:a33d80b6e352 "mv dir/ dir2/" (tip)
merging dir/a and dir2/a to dir2/a
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/a33d80b6e352-fecb9ada-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Move file twice and rebase mod on top of moves
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ hg mv a b
$ hg ci -m 'mv a b'
$ hg mv b c
$ hg ci -m 'mv b c'
$ hg up -q 0
$ echo c > a
$ hg ci -m 'mod a'
created new head
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: d413169422167a3fa5275fc5d71f7dea9f5775f3
| desc: mod a, phase: draft
| o changeset: d3efd280421d24f9f229997c19e654761c942a71
| | desc: mv b c, phase: draft
| o changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
|/ desc: mv a b, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg rebase -s . -d 2
rebasing 3:d41316942216 "mod a" (tip)
merging c and a to c
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/d41316942216-2b5949bc-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Move file twice and rebase moves on top of mods
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ hg mv a b
$ hg ci -m 'mv a b'
$ hg mv b c
$ hg ci -m 'mv b c'
$ hg up -q 0
$ echo c > a
$ hg ci -m 'mod a'
created new head
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: d413169422167a3fa5275fc5d71f7dea9f5775f3
| desc: mod a, phase: draft
| o changeset: d3efd280421d24f9f229997c19e654761c942a71
| | desc: mv b c, phase: draft
| o changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
|/ desc: mv a b, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg rebase -s 1 -d .
rebasing 1:472e38d57782 "mv a b"
merging a and b to b
rebasing 2:d3efd280421d "mv b c"
merging b and c to c
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/472e38d57782-ab8d3c58-rebase.hg (glob)
$ cd ..
$ rm -rf server
$ rm -rf repo
Move one file and add another file in the same folder in one branch, modify file in another branch
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ hg mv a b
$ hg ci -m 'mv a b'
$ echo c > c
$ hg add c
$ hg ci -m 'add c'
$ hg up -q 0
$ echo b > a
$ hg ci -m 'mod a'
created new head
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
| desc: mod a, phase: draft
| o changeset: b1a6187e79fbce851bb584eadcb0cc4a80290fd9
| | desc: add c, phase: draft
| o changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
|/ desc: mv a b, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg rebase -s . -d 2
rebasing 3:ef716627c70b "mod a" (tip)
merging b and a to b
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/ef716627c70b-24681561-rebase.hg (glob)
$ ls
b
c
$ cat b
b
Merge test
$ hg init server
$ cd server
$ echo a > a
$ hg add a
$ hg ci -m initial
$ echo b > a
$ hg ci -m 'modify a'
$ hg up -q 0
$ hg mv a b
$ hg ci -m 'mv a b'
created new head
$ cd ..
$ hg clone -q server repo
$ initclient repo
$ cd repo
$ hg up -q 2
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
| desc: mv a b, phase: public
| o changeset: b0357b07f79129a3d08a68621271ca1352ae8a09
|/ desc: modify a, phase: public
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: public
$ hg merge 1
merging b and a to b
0 files updated, 1 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit)
$ hg ci -m merge
$ ls
b
$ cd ..
$ rm -rf server
$ rm -rf repo
Copy and move file
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ hg cp a c
$ hg mv a b
$ hg ci -m 'cp a c, mv a b'
$ hg up -q 0
$ echo b > a
$ hg ci -m 'mod a'
created new head
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
| desc: mod a, phase: draft
| o changeset: 4fc3fd13fbdb89ada6b75bfcef3911a689a0dde8
|/ desc: cp a c, mv a b, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg rebase -s . -d 1
rebasing 2:ef716627c70b "mod a" (tip)
merging b and a to b
merging c and a to c
saved backup bundle to $TESTTMP/repo/repo/.hg/strip-backup/ef716627c70b-24681561-rebase.hg (glob)
$ ls
b
c
$ cat b
b
$ cat c
b
$ cd ..
$ rm -rf server
$ rm -rf repo
Do a merge commit with many consequent moves in one branch
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ echo b > a
$ hg ci -qm 'mod a'
$ hg up -q ".^"
$ hg mv a b
$ hg ci -qm 'mv a b'
$ hg mv b c
$ hg ci -qm 'mv b c'
$ hg up -q 1
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
o changeset: d3efd280421d24f9f229997c19e654761c942a71
| desc: mv b c, phase: draft
o changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
| desc: mv a b, phase: draft
| @ changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
|/ desc: mod a, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg merge 3
merging a and c to c
0 files updated, 1 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit)
$ hg ci -qm 'merge'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: cd29b0d08c0f39bfed4cde1b40e30f419db0c825
|\ desc: merge, phase: draft
| o changeset: d3efd280421d24f9f229997c19e654761c942a71
| | desc: mv b c, phase: draft
| o changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
| | desc: mv a b, phase: draft
o | changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
|/ desc: mod a, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ ls
c
$ cd ..
$ rm -rf server
$ rm -rf repo
Test shelve/unshelve
$ hg init repo
$ initclient repo
$ cd repo
$ echo a > a
$ hg add a
$ hg ci -m initial
$ echo b > a
$ hg shelve
shelved as default
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg mv a b
$ hg ci -m 'mv a b'
$ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
@ changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
| desc: mv a b, phase: draft
o changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
desc: initial, phase: draft
$ hg unshelve
unshelving change 'default'
rebasing shelved changes
rebasing 2:45f63161acea "changes to: initial" (tip)
merging b and a to b
$ ls
b
$ cat b
b
$ cd ..
$ rm -rf server
$ rm -rf repo