Mercurial > hg > mercurial-crew-with-dirclash
annotate mercurial/localrepo.py @ 1959:d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
before this, push would not push from e.g. "hg" repo to "kernel" repo
but other commands worked. this was bad idea, could merge unrelated
projects by accident. i did this tonight.
now, all commands still work with unrelated repo but need
--force/-f. abort is default. this is safer.
| author | Vadim Gelfer <vadim.gelfer@gmail.com> |
|---|---|
| date | Tue, 14 Mar 2006 22:58:14 -0800 |
| parents | 65aff2ed61ae |
| children | 72f7a335b955 |
| rev | line source |
|---|---|
| 1089 | 1 # localrepo.py - read/write repository class for mercurial |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
2 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
3 # Copyright 2005 Matt Mackall <mpm@selenic.com> |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
4 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
5 # This software may be used and distributed according to the terms |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
6 # of the GNU General Public License, incorporated herein by reference. |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
7 |
|
1097
1f89ccbab6ce
localrepo: adjust some imports, remove sys dependency
mpm@selenic.com
parents:
1089
diff
changeset
|
8 import struct, os, util |
| 1100 | 9 import filelog, manifest, changelog, dirstate, repo |
| 10 from node import * | |
|
1400
cf9a1233738a
i18n first part: make '_' available for files who need it
Benoit Boissinot <benoit.boissinot@ens-lyon.org
parents:
1398
diff
changeset
|
11 from i18n import gettext as _ |
| 262 | 12 from demandload import * |
|
1839
876e4e6ad82b
Create local ui object per repository, so .hg/hgrc don't get mixed.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1838
diff
changeset
|
13 demandload(globals(), "re lock transaction tempfile stat mdiff errno ui") |
| 499 | 14 |
|
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1551
diff
changeset
|
15 class localrepository(object): |
|
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
16 def __del__(self): |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
17 self.transhandle = None |
|
1839
876e4e6ad82b
Create local ui object per repository, so .hg/hgrc don't get mixed.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1838
diff
changeset
|
18 def __init__(self, parentui, path=None, create=0): |
| 1101 | 19 if not path: |
| 20 p = os.getcwd() | |
| 21 while not os.path.isdir(os.path.join(p, ".hg")): | |
| 22 oldp = p | |
| 23 p = os.path.dirname(p) | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
24 if p == oldp: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
25 raise repo.RepoError(_("no repo found")) |
| 1101 | 26 path = p |
| 27 self.path = os.path.join(path, ".hg") | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
28 |
| 1101 | 29 if not create and not os.path.isdir(self.path): |
|
1588
a679a364436a
Better error message (without /.hg appended) when repository is not found.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1586
diff
changeset
|
30 raise repo.RepoError(_("repository %s not found") % path) |
| 405 | 31 |
|
933
9c43d68ad59f
Fixed --repository option when handling relative path
tksoh@users.sf.net
parents:
926
diff
changeset
|
32 self.root = os.path.abspath(path) |
|
1839
876e4e6ad82b
Create local ui object per repository, so .hg/hgrc don't get mixed.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1838
diff
changeset
|
33 self.ui = ui.ui(parentui=parentui) |
|
1102
c81d264cd17d
localrepo: minor opener usage restructuring
mpm@selenic.com
parents:
1101
diff
changeset
|
34 self.opener = util.opener(self.path) |
|
c81d264cd17d
localrepo: minor opener usage restructuring
mpm@selenic.com
parents:
1101
diff
changeset
|
35 self.wopener = util.opener(self.root) |
| 1100 | 36 self.manifest = manifest.manifest(self.opener) |
| 37 self.changelog = changelog.changelog(self.opener) | |
| 343 | 38 self.tagscache = None |
| 39 self.nodetagscache = None | |
| 1258 | 40 self.encodepats = None |
| 41 self.decodepats = None | |
|
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
42 self.transhandle = None |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
43 |
|
1133
899b619a7eb2
Create [web] section with short username as contact on hg init and hg clone.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1117
diff
changeset
|
44 if create: |
|
899b619a7eb2
Create [web] section with short username as contact on hg init and hg clone.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1117
diff
changeset
|
45 os.mkdir(self.path) |
|
899b619a7eb2
Create [web] section with short username as contact on hg init and hg clone.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1117
diff
changeset
|
46 os.mkdir(self.join("data")) |
|
899b619a7eb2
Create [web] section with short username as contact on hg init and hg clone.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1117
diff
changeset
|
47 |
|
1839
876e4e6ad82b
Create local ui object per repository, so .hg/hgrc don't get mixed.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1838
diff
changeset
|
48 self.dirstate = dirstate.dirstate(self.opener, self.ui, self.root) |
| 1101 | 49 try: |
|
1893
6569651a4f1e
Read paths specified in .hg/hgrc relative to repo root, otherwise to home dir.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1885
diff
changeset
|
50 self.ui.readconfig(self.join("hgrc"), self.root) |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
51 except IOError: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
52 pass |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
53 |
|
1718
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
54 def hook(self, name, throw=False, **args): |
|
1480
ae0d8d632b83
allow multiples hook
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1477
diff
changeset
|
55 def runhook(name, cmd): |
|
ae0d8d632b83
allow multiples hook
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1477
diff
changeset
|
56 self.ui.note(_("running hook %s: %s\n") % (name, cmd)) |
|
1880
05c7d75be925
fix broken environment save/restore when a hook runs.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1853
diff
changeset
|
57 env = dict([('HG_' + k.upper(), v) for k, v in args.iteritems()]) |
|
1882
c0320567931f
merge util.esystem and util.system.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1880
diff
changeset
|
58 r = util.system(cmd, environ=env, cwd=self.root) |
| 487 | 59 if r: |
|
1718
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
60 desc, r = util.explain_exit(r) |
|
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
61 if throw: |
|
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
62 raise util.Abort(_('%s hook %s') % (name, desc)) |
|
c1996b84d4f5
make hook code nicer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1717
diff
changeset
|
63 self.ui.warn(_('error: %s hook %s\n') % (name, desc)) |
| 487 | 64 return False |
|
1480
ae0d8d632b83
allow multiples hook
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1477
diff
changeset
|
65 return True |
|
ae0d8d632b83
allow multiples hook
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1477
diff
changeset
|
66 |
|
ae0d8d632b83
allow multiples hook
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1477
diff
changeset
|
67 r = True |
|
1838
429bf036f2cb
Call hooks in alphabetical (=defined) order, of course still grouped by type.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1835
diff
changeset
|
68 hooks = [(hname, cmd) for hname, cmd in self.ui.configitems("hooks") |
|
429bf036f2cb
Call hooks in alphabetical (=defined) order, of course still grouped by type.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1835
diff
changeset
|
69 if hname.split(".", 1)[0] == name and cmd] |
|
429bf036f2cb
Call hooks in alphabetical (=defined) order, of course still grouped by type.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1835
diff
changeset
|
70 hooks.sort() |
|
429bf036f2cb
Call hooks in alphabetical (=defined) order, of course still grouped by type.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1835
diff
changeset
|
71 for hname, cmd in hooks: |
|
429bf036f2cb
Call hooks in alphabetical (=defined) order, of course still grouped by type.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1835
diff
changeset
|
72 r = runhook(hname, cmd) and r |
|
1480
ae0d8d632b83
allow multiples hook
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1477
diff
changeset
|
73 return r |
| 487 | 74 |
| 343 | 75 def tags(self): |
| 76 '''return a mapping of tag to node''' | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
77 if not self.tagscache: |
| 343 | 78 self.tagscache = {} |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
79 def addtag(self, k, n): |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
80 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
81 bin_n = bin(n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
82 except TypeError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
83 bin_n = '' |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
84 self.tagscache[k.strip()] = bin_n |
| 659 | 85 |
| 67 | 86 try: |
| 254 | 87 # read each head of the tags file, ending with the tip |
| 88 # and add each tag found to the map, with "newer" ones | |
| 89 # taking precedence | |
| 67 | 90 fl = self.file(".hgtags") |
| 254 | 91 h = fl.heads() |
| 92 h.reverse() | |
| 93 for r in h: | |
|
994
88c15682d9b0
Fix callers to file.revision to use file.read
mpm@selenic.com
parents:
993
diff
changeset
|
94 for l in fl.read(r).splitlines(): |
| 254 | 95 if l: |
|
385
e9e1efd5291c
Fixed problems with extra spaces around tags in .hgtags
Thomas Arendsen Hein <thomas@intevation.de>
parents:
383
diff
changeset
|
96 n, k = l.split(" ", 1) |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
97 addtag(self, k, n) |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
98 except KeyError: |
|
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
99 pass |
| 659 | 100 |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
101 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
102 f = self.opener("localtags") |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
103 for l in f: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
104 n, k = l.split(" ", 1) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
105 addtag(self, k, n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
106 except IOError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
107 pass |
| 659 | 108 |
| 343 | 109 self.tagscache['tip'] = self.changelog.tip() |
| 659 | 110 |
| 343 | 111 return self.tagscache |
| 112 | |
| 113 def tagslist(self): | |
| 114 '''return a list of tags ordered by revision''' | |
| 115 l = [] | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
116 for t, n in self.tags().items(): |
| 343 | 117 try: |
| 118 r = self.changelog.rev(n) | |
| 119 except: | |
| 120 r = -2 # sort to the beginning of the list if unknown | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
121 l.append((r, t, n)) |
| 343 | 122 l.sort() |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
123 return [(t, n) for r, t, n in l] |
| 343 | 124 |
| 125 def nodetags(self, node): | |
| 126 '''return the tags associated with a node''' | |
| 127 if not self.nodetagscache: | |
| 128 self.nodetagscache = {} | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
129 for t, n in self.tags().items(): |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
130 self.nodetagscache.setdefault(n, []).append(t) |
| 343 | 131 return self.nodetagscache.get(node, []) |
| 132 | |
| 133 def lookup(self, key): | |
| 67 | 134 try: |
| 343 | 135 return self.tags()[key] |
| 67 | 136 except KeyError: |
|
658
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
137 try: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
138 return self.changelog.lookup(key) |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
139 except: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
140 raise repo.RepoError(_("unknown revision '%s'") % key) |
| 67 | 141 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
142 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
143 return os.stat(self.path).st_dev |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
144 |
| 926 | 145 def local(self): |
| 1101 | 146 return True |
| 926 | 147 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
148 def join(self, f): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
149 return os.path.join(self.path, f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
150 |
| 244 | 151 def wjoin(self, f): |
| 152 return os.path.join(self.root, f) | |
| 153 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
154 def file(self, f): |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
155 if f[0] == '/': |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
156 f = f[1:] |
| 1100 | 157 return filelog.filelog(self.opener, f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
158 |
| 627 | 159 def getcwd(self): |
|
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
160 return self.dirstate.getcwd() |
| 627 | 161 |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
162 def wfile(self, f, mode='r'): |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
163 return self.wopener(f, mode) |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
164 |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
165 def wread(self, filename): |
| 1258 | 166 if self.encodepats == None: |
| 167 l = [] | |
| 168 for pat, cmd in self.ui.configitems("encode"): | |
|
1947
65aff2ed61ae
fix the call to util.matcher (the args should be (reporoot, cwd, ...))
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1938
diff
changeset
|
169 mf = util.matcher(self.root, "", [pat], [], [])[1] |
| 1258 | 170 l.append((mf, cmd)) |
| 171 self.encodepats = l | |
| 172 | |
| 173 data = self.wopener(filename, 'r').read() | |
| 174 | |
| 175 for mf, cmd in self.encodepats: | |
| 176 if mf(filename): | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
177 self.ui.debug(_("filtering %s through %s\n") % (filename, cmd)) |
| 1258 | 178 data = util.filter(data, cmd) |
| 179 break | |
| 180 | |
| 181 return data | |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
182 |
|
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
183 def wwrite(self, filename, data, fd=None): |
| 1258 | 184 if self.decodepats == None: |
| 185 l = [] | |
| 186 for pat, cmd in self.ui.configitems("decode"): | |
|
1947
65aff2ed61ae
fix the call to util.matcher (the args should be (reporoot, cwd, ...))
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1938
diff
changeset
|
187 mf = util.matcher(self.root, "", [pat], [], [])[1] |
| 1258 | 188 l.append((mf, cmd)) |
| 189 self.decodepats = l | |
| 190 | |
| 191 for mf, cmd in self.decodepats: | |
| 192 if mf(filename): | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
193 self.ui.debug(_("filtering %s through %s\n") % (filename, cmd)) |
| 1258 | 194 data = util.filter(data, cmd) |
| 195 break | |
| 196 | |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
197 if fd: |
|
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
198 return fd.write(data) |
|
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
199 return self.wopener(filename, 'w').write(data) |
|
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
200 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
201 def transaction(self): |
|
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
202 tr = self.transhandle |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
203 if tr != None and tr.running(): |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
204 return tr.nest() |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
205 |
| 251 | 206 # save dirstate for undo |
| 263 | 207 try: |
| 208 ds = self.opener("dirstate").read() | |
| 209 except IOError: | |
| 210 ds = "" | |
| 785 | 211 self.opener("journal.dirstate", "w").write(ds) |
| 515 | 212 |
|
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
213 tr = transaction.transaction(self.ui.warn, self.opener, |
|
1880
05c7d75be925
fix broken environment save/restore when a hook runs.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1853
diff
changeset
|
214 self.join("journal"), |
|
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
215 aftertrans(self.path)) |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
216 self.transhandle = tr |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
217 return tr |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
218 |
| 210 | 219 def recover(self): |
|
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
220 l = self.lock() |
| 557 | 221 if os.path.exists(self.join("journal")): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
222 self.ui.status(_("rolling back interrupted transaction\n")) |
|
1516
0b1b029b4de3
Automatically run "verify" whenever we run "recover"
Matt Mackall <mpm@selenic.com>
parents:
1510
diff
changeset
|
223 transaction.rollback(self.opener, self.join("journal")) |
|
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
224 self.reload() |
|
1516
0b1b029b4de3
Automatically run "verify" whenever we run "recover"
Matt Mackall <mpm@selenic.com>
parents:
1510
diff
changeset
|
225 return True |
| 210 | 226 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
227 self.ui.warn(_("no interrupted transaction available\n")) |
|
1516
0b1b029b4de3
Automatically run "verify" whenever we run "recover"
Matt Mackall <mpm@selenic.com>
parents:
1510
diff
changeset
|
228 return False |
| 210 | 229 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
230 def undo(self, wlock=None): |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
231 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
232 wlock = self.wlock() |
|
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
233 l = self.lock() |
| 210 | 234 if os.path.exists(self.join("undo")): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
235 self.ui.status(_("rolling back last transaction\n")) |
| 262 | 236 transaction.rollback(self.opener, self.join("undo")) |
| 421 | 237 util.rename(self.join("undo.dirstate"), self.join("dirstate")) |
|
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
238 self.reload() |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
239 self.wreload() |
| 163 | 240 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
241 self.ui.warn(_("no undo information available\n")) |
| 162 | 242 |
|
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
243 def wreload(self): |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
244 self.dirstate.read() |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
245 |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
246 def reload(self): |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
247 self.changelog.load() |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
248 self.manifest.load() |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
249 self.tagscache = None |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
250 self.nodetagscache = None |
|
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
251 |
|
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
252 def do_lock(self, lockname, wait, releasefn=None, acquirefn=None): |
| 161 | 253 try: |
|
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
254 l = lock.lock(self.join(lockname), 0, releasefn) |
|
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
255 except lock.LockHeld, inst: |
|
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
256 if not wait: |
|
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
257 raise inst |
|
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
258 self.ui.warn(_("waiting for lock held by %s\n") % inst.args[0]) |
|
1787
e431344e604c
add a timeout when a lock is held (default 1024 sec)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
259 try: |
|
1788
750b9cd83965
change the default timeout to 600 seconds
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1787
diff
changeset
|
260 # default to 600 seconds timeout |
|
1787
e431344e604c
add a timeout when a lock is held (default 1024 sec)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
261 l = lock.lock(self.join(lockname), |
|
1788
750b9cd83965
change the default timeout to 600 seconds
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1787
diff
changeset
|
262 int(self.ui.config("ui", "timeout") or 600), |
|
1787
e431344e604c
add a timeout when a lock is held (default 1024 sec)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
263 releasefn) |
|
e431344e604c
add a timeout when a lock is held (default 1024 sec)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
264 except lock.LockHeld, inst: |
|
e431344e604c
add a timeout when a lock is held (default 1024 sec)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
265 raise util.Abort(_("timeout while waiting for " |
|
e431344e604c
add a timeout when a lock is held (default 1024 sec)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
266 "lock held by %s") % inst.args[0]) |
|
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
267 if acquirefn: |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
268 acquirefn() |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
269 return l |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
270 |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
271 def lock(self, wait=1): |
|
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
272 return self.do_lock("lock", wait, acquirefn=self.reload) |
|
1751
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
273 |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
274 def wlock(self, wait=1): |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
275 return self.do_lock("wlock", wait, |
|
e9bf415a8ecb
localrepo: refactor the locking functions
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
276 self.dirstate.write, |
|
1784
2e0a288ca93e
revalidate revlog data after locking the repo (issue132)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1782
diff
changeset
|
277 self.wreload) |
|
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
278 |
|
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
279 def checkfilemerge(self, filename, text, filelog, manifest1, manifest2): |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
280 "determine whether a new filenode is needed" |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
281 fp1 = manifest1.get(filename, nullid) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
282 fp2 = manifest2.get(filename, nullid) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
283 |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
284 if fp2 != nullid: |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
285 # is one parent an ancestor of the other? |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
286 fpa = filelog.ancestor(fp1, fp2) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
287 if fpa == fp1: |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
288 fp1, fp2 = fp2, nullid |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
289 elif fpa == fp2: |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
290 fp2 = nullid |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
291 |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
292 # is the file unmodified from the parent? report existing entry |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
293 if fp2 == nullid and text == filelog.read(fp1): |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
294 return (fp1, None, None) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
295 |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
296 return (None, fp1, fp2) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
297 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
298 def rawcommit(self, files, text, user, date, p1=None, p2=None, wlock=None): |
| 442 | 299 orig_parent = self.dirstate.parents()[0] or nullid |
|
452
a1e91c24dab5
rawcommit: do lookup of parents at the appropriate layer
mpm@selenic.com
parents:
442
diff
changeset
|
300 p1 = p1 or self.dirstate.parents()[0] or nullid |
|
a1e91c24dab5
rawcommit: do lookup of parents at the appropriate layer
mpm@selenic.com
parents:
442
diff
changeset
|
301 p2 = p2 or self.dirstate.parents()[1] or nullid |
| 302 | 302 c1 = self.changelog.read(p1) |
| 303 c2 = self.changelog.read(p2) | |
| 304 m1 = self.manifest.read(c1[0]) | |
| 305 mf1 = self.manifest.readflags(c1[0]) | |
| 306 m2 = self.manifest.read(c2[0]) | |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
307 changed = [] |
| 302 | 308 |
| 442 | 309 if orig_parent == p1: |
| 310 update_dirstate = 1 | |
| 311 else: | |
| 312 update_dirstate = 0 | |
| 313 | |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
314 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
315 wlock = self.wlock() |
|
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
316 l = self.lock() |
| 203 | 317 tr = self.transaction() |
| 302 | 318 mm = m1.copy() |
| 319 mfm = mf1.copy() | |
| 203 | 320 linkrev = self.changelog.count() |
| 321 for f in files: | |
| 322 try: | |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
323 t = self.wread(f) |
| 441 | 324 tm = util.is_exec(self.wjoin(f), mfm.get(f, False)) |
| 302 | 325 r = self.file(f) |
| 326 mfm[f] = tm | |
| 990 | 327 |
|
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
328 (entry, fp1, fp2) = self.checkfilemerge(f, t, r, m1, m2) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
329 if entry: |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
330 mm[f] = entry |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
331 continue |
| 990 | 332 |
| 333 mm[f] = r.add(t, {}, tr, linkrev, fp1, fp2) | |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
334 changed.append(f) |
| 442 | 335 if update_dirstate: |
| 336 self.dirstate.update([f], "n") | |
| 203 | 337 except IOError: |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
338 try: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
339 del mm[f] |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
340 del mfm[f] |
| 442 | 341 if update_dirstate: |
| 342 self.dirstate.forget([f]) | |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
343 except: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
344 # deleted from p2? |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
345 pass |
| 203 | 346 |
| 302 | 347 mnode = self.manifest.add(mm, mfm, tr, linkrev, c1[0], c2[0]) |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
348 user = user or self.ui.username() |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
349 n = self.changelog.add(mnode, changed, text, tr, p1, p2, user, date) |
| 203 | 350 tr.close() |
| 442 | 351 if update_dirstate: |
| 352 self.dirstate.setparents(n, nullid) | |
| 203 | 353 |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
354 def commit(self, files=None, text="", user=None, date=None, |
|
1807
f1f43ea22cbf
Allow repo lock to be passed in to localrepo.commit for performance
mason@suse.com
parents:
1806
diff
changeset
|
355 match=util.always, force=False, lock=None, wlock=None): |
| 220 | 356 commit = [] |
| 357 remove = [] | |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
358 changed = [] |
|
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
359 |
| 220 | 360 if files: |
| 361 for f in files: | |
| 362 s = self.dirstate.state(f) | |
| 244 | 363 if s in 'nmai': |
| 220 | 364 commit.append(f) |
| 365 elif s == 'r': | |
| 366 remove.append(f) | |
| 367 else: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
368 self.ui.warn(_("%s not tracked!\n") % f) |
| 220 | 369 else: |
|
1619
1ba0d7041ac4
Distinguish removed and deleted files. Tests are not fixed yet.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1618
diff
changeset
|
370 modified, added, removed, deleted, unknown = self.changes(match=match) |
|
1618
ff339dd21976
Renamed c, a, d, u to modified, added, removed, unknown for users of changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1617
diff
changeset
|
371 commit = modified + added |
|
ff339dd21976
Renamed c, a, d, u to modified, added, removed, unknown for users of changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1617
diff
changeset
|
372 remove = removed |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
373 |
| 990 | 374 p1, p2 = self.dirstate.parents() |
| 375 c1 = self.changelog.read(p1) | |
| 376 c2 = self.changelog.read(p2) | |
| 377 m1 = self.manifest.read(c1[0]) | |
| 378 mf1 = self.manifest.readflags(c1[0]) | |
| 379 m2 = self.manifest.read(c2[0]) | |
| 380 | |
| 381 if not commit and not remove and not force and p2 == nullid: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
382 self.ui.status(_("nothing changed\n")) |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
383 return None |
| 151 | 384 |
|
1721
801756d0ca84
add pretxncommit hook.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1719
diff
changeset
|
385 xp1 = hex(p1) |
|
801756d0ca84
add pretxncommit hook.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1719
diff
changeset
|
386 if p2 == nullid: xp2 = '' |
|
801756d0ca84
add pretxncommit hook.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1719
diff
changeset
|
387 else: xp2 = hex(p2) |
|
801756d0ca84
add pretxncommit hook.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1719
diff
changeset
|
388 |
|
1727
019e6a47a53e
fix names of parent changeset ids in hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1726
diff
changeset
|
389 self.hook("precommit", throw=True, parent1=xp1, parent2=xp2) |
| 487 | 390 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
391 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
392 wlock = self.wlock() |
|
1807
f1f43ea22cbf
Allow repo lock to be passed in to localrepo.commit for performance
mason@suse.com
parents:
1806
diff
changeset
|
393 if not lock: |
|
f1f43ea22cbf
Allow repo lock to be passed in to localrepo.commit for performance
mason@suse.com
parents:
1806
diff
changeset
|
394 lock = self.lock() |
| 151 | 395 tr = self.transaction() |
| 396 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
397 # check in files |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
398 new = {} |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
399 linkrev = self.changelog.count() |
| 220 | 400 commit.sort() |
| 401 for f in commit: | |
| 83 | 402 self.ui.note(f + "\n") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
403 try: |
| 441 | 404 mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False)) |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
405 t = self.wread(f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
406 except IOError: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
407 self.ui.warn(_("trouble committing %s!\n") % f) |
| 220 | 408 raise |
| 409 | |
| 1117 | 410 r = self.file(f) |
| 411 | |
| 363 | 412 meta = {} |
| 413 cp = self.dirstate.copied(f) | |
| 414 if cp: | |
| 415 meta["copy"] = cp | |
| 416 meta["copyrev"] = hex(m1.get(cp, m2.get(cp, nullid))) | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
417 self.ui.debug(_(" %s: copy %s:%s\n") % (f, cp, meta["copyrev"])) |
| 1117 | 418 fp1, fp2 = nullid, nullid |
| 419 else: | |
|
1716
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
420 entry, fp1, fp2 = self.checkfilemerge(f, t, r, m1, m2) |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
421 if entry: |
|
ef8cd889a78b
Refactor excessive merge detection, add test
Matt Mackall <mpm@selenic.com>
parents:
1713
diff
changeset
|
422 new[f] = entry |
| 990 | 423 continue |
| 424 | |
| 363 | 425 new[f] = r.add(t, meta, tr, linkrev, fp1, fp2) |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
426 # remember what we've added so that we can later calculate |
|
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
427 # the files to pull from a set of changesets |
|
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
428 changed.append(f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
429 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
430 # update manifest |
|
1629
3024cacfb2c9
Copy manifest map before modifying it (see issue86)
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1621
diff
changeset
|
431 m1 = m1.copy() |
| 229 | 432 m1.update(new) |
|
416
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
433 for f in remove: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
434 if f in m1: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
435 del m1[f] |
| 741 | 436 mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0], |
| 437 (new, remove)) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
438 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
439 # add changeset |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
440 new = new.keys() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
441 new.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
442 |
| 288 | 443 if not text: |
|
1709
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
444 edittext = [""] |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
445 if p2 != nullid: |
|
1709
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
446 edittext.append("HG: branch merge") |
|
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
447 edittext.extend(["HG: changed %s" % f for f in changed]) |
|
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
448 edittext.extend(["HG: removed %s" % f for f in remove]) |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
449 if not changed and not remove: |
|
1709
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
450 edittext.append("HG: no files changed") |
|
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
451 edittext.append("") |
|
1706
20b621154e17
Run commit message editor in the repo root (like hooks).
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1680
diff
changeset
|
452 # run editor in the repository root |
|
20b621154e17
Run commit message editor in the repo root (like hooks).
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1680
diff
changeset
|
453 olddir = os.getcwd() |
|
20b621154e17
Run commit message editor in the repo root (like hooks).
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1680
diff
changeset
|
454 os.chdir(self.root) |
|
1709
069129d24b26
Create default commit message in a more pythonic way.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1708
diff
changeset
|
455 edittext = self.ui.edit("\n".join(edittext)) |
|
1706
20b621154e17
Run commit message editor in the repo root (like hooks).
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1680
diff
changeset
|
456 os.chdir(olddir) |
| 288 | 457 if not edittext.rstrip(): |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
458 return None |
| 288 | 459 text = edittext |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
460 |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
461 user = user or self.ui.username() |
|
1645
c6ffedc4f11b
add removed files to the changelog file list
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1632
diff
changeset
|
462 n = self.changelog.add(mn, changed + remove, text, tr, p1, p2, user, date) |
|
1727
019e6a47a53e
fix names of parent changeset ids in hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1726
diff
changeset
|
463 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1, |
|
019e6a47a53e
fix names of parent changeset ids in hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1726
diff
changeset
|
464 parent2=xp2) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
465 tr.close() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
466 |
| 229 | 467 self.dirstate.setparents(n) |
| 220 | 468 self.dirstate.update(new, "n") |
| 469 self.dirstate.forget(remove) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
470 |
|
1727
019e6a47a53e
fix names of parent changeset ids in hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1726
diff
changeset
|
471 self.hook("commit", node=hex(n), parent1=xp1, parent2=xp2) |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
472 return n |
|
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
473 |
| 1062 | 474 def walk(self, node=None, files=[], match=util.always): |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
475 if node: |
|
1582
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
476 fdict = dict.fromkeys(files) |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
477 for fn in self.manifest.read(self.changelog.read(node)[0]): |
|
1582
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
478 fdict.pop(fn, None) |
|
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
479 if match(fn): |
|
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
480 yield 'm', fn |
|
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
481 for fn in fdict: |
|
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
482 self.ui.warn(_('%s: No such file in rev %s\n') % ( |
|
63799b01985c
fix the cat command
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
483 util.pathto(self.getcwd(), fn), short(node))) |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
484 else: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
485 for src, fn in self.dirstate.walk(files, match): |
|
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
486 yield src, fn |
| 723 | 487 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
488 def changes(self, node1=None, node2=None, files=[], match=util.always, |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
489 wlock=None): |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
490 """return changes between two nodes or node and working directory |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
491 |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
492 If node1 is None, use the first dirstate parent instead. |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
493 If node2 is None, compare node1 with working directory. |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
494 """ |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
495 |
| 536 | 496 def fcmp(fn, mf): |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
497 t1 = self.wread(fn) |
|
994
88c15682d9b0
Fix callers to file.revision to use file.read
mpm@selenic.com
parents:
993
diff
changeset
|
498 t2 = self.file(fn).read(mf.get(fn, nullid)) |
| 29 | 499 return cmp(t1, t2) |
| 500 | |
| 723 | 501 def mfmatches(node): |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
502 change = self.changelog.read(node) |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
503 mf = dict(self.manifest.read(change[0])) |
| 723 | 504 for fn in mf.keys(): |
| 505 if not match(fn): | |
| 506 del mf[fn] | |
| 507 return mf | |
| 741 | 508 |
|
1802
8a7a24b96697
speed up hg log --debug
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
1789
diff
changeset
|
509 if node1: |
|
8a7a24b96697
speed up hg log --debug
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
1789
diff
changeset
|
510 # read the manifest from node1 before the manifest from node2, |
|
8a7a24b96697
speed up hg log --debug
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
1789
diff
changeset
|
511 # so that we'll hit the manifest cache if we're going through |
|
8a7a24b96697
speed up hg log --debug
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
1789
diff
changeset
|
512 # all the revisions in parent->child order. |
|
8a7a24b96697
speed up hg log --debug
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
1789
diff
changeset
|
513 mf1 = mfmatches(node1) |
|
8a7a24b96697
speed up hg log --debug
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
1789
diff
changeset
|
514 |
| 536 | 515 # are we comparing the working directory? |
| 561 | 516 if not node2: |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
517 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
518 try: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
519 wlock = self.wlock(wait=0) |
|
1754
fdfe89a3962d
use repo.lock when cloning via copy, use lock.LockException when necessary
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1752
diff
changeset
|
520 except lock.LockException: |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
521 wlock = None |
|
1617
ece5d785e87a
Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1616
diff
changeset
|
522 lookup, modified, added, removed, deleted, unknown = ( |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
523 self.dirstate.changes(files, match)) |
| 536 | 524 |
| 525 # are we comparing working dir against its parent? | |
| 561 | 526 if not node1: |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
527 if lookup: |
| 536 | 528 # do a full compare of any files that might have changed |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
529 mf2 = mfmatches(self.dirstate.parents()[0]) |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
530 for f in lookup: |
| 561 | 531 if fcmp(f, mf2): |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
532 modified.append(f) |
|
1532
27077812fffb
reset mtime when two files are equal
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1531
diff
changeset
|
533 elif wlock is not None: |
|
27077812fffb
reset mtime when two files are equal
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1531
diff
changeset
|
534 self.dirstate.update([f], "n") |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
535 else: |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
536 # we are comparing working dir against non-parent |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
537 # generate a pseudo-manifest for the working dir |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
538 mf2 = mfmatches(self.dirstate.parents()[0]) |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
539 for f in lookup + modified + added: |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
540 mf2[f] = "" |
|
1617
ece5d785e87a
Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1616
diff
changeset
|
541 for f in removed: |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
542 if f in mf2: |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
543 del mf2[f] |
| 536 | 544 else: |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
545 # we are comparing two revisions |
|
1617
ece5d785e87a
Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1616
diff
changeset
|
546 deleted, unknown = [], [] |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
547 mf2 = mfmatches(node2) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
548 |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
549 if node1: |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
550 # flush lists from dirstate before comparing manifests |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
551 modified, added = [], [] |
| 566 | 552 |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
553 for fn in mf2: |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
554 if mf1.has_key(fn): |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
555 if mf1[fn] != mf2[fn] and (mf2[fn] != "" or fcmp(fn, mf1)): |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
556 modified.append(fn) |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
557 del mf1[fn] |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
558 else: |
|
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
559 added.append(fn) |
| 515 | 560 |
|
1617
ece5d785e87a
Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1616
diff
changeset
|
561 removed = mf1.keys() |
|
ece5d785e87a
Make localrepo.changes() internally distinguish between removed and deleted.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1616
diff
changeset
|
562 |
|
1616
f0f9e84849e7
Cleaned up localrepo.changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1615
diff
changeset
|
563 # sort and return results: |
|
1619
1ba0d7041ac4
Distinguish removed and deleted files. Tests are not fixed yet.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1618
diff
changeset
|
564 for l in modified, added, removed, deleted, unknown: |
| 561 | 565 l.sort() |
|
1619
1ba0d7041ac4
Distinguish removed and deleted files. Tests are not fixed yet.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1618
diff
changeset
|
566 return (modified, added, removed, deleted, unknown) |
| 32 | 567 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
568 def add(self, list, wlock=None): |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
569 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
570 wlock = self.wlock() |
| 220 | 571 for f in list: |
| 244 | 572 p = self.wjoin(f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
573 if not os.path.exists(p): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
574 self.ui.warn(_("%s does not exist!\n") % f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
575 elif not os.path.isfile(p): |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
576 self.ui.warn(_("%s not added: only files supported currently\n") |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
577 % f) |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
578 elif self.dirstate.state(f) in 'an': |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
579 self.ui.warn(_("%s already tracked!\n") % f) |
| 220 | 580 else: |
| 581 self.dirstate.update([f], "a") | |
| 582 | |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
583 def forget(self, list, wlock=None): |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
584 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
585 wlock = self.wlock() |
| 220 | 586 for f in list: |
| 587 if self.dirstate.state(f) not in 'ai': | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
588 self.ui.warn(_("%s not added!\n") % f) |
| 220 | 589 else: |
| 590 self.dirstate.forget([f]) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
591 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
592 def remove(self, list, unlink=False, wlock=None): |
|
1415
c6e6ca96a033
refactor some unlink/remove code and make sure we prune empty dir
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
593 if unlink: |
|
c6e6ca96a033
refactor some unlink/remove code and make sure we prune empty dir
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
594 for f in list: |
|
c6e6ca96a033
refactor some unlink/remove code and make sure we prune empty dir
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
595 try: |
|
c6e6ca96a033
refactor some unlink/remove code and make sure we prune empty dir
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
596 util.unlink(self.wjoin(f)) |
|
c6e6ca96a033
refactor some unlink/remove code and make sure we prune empty dir
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
597 except OSError, inst: |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
598 if inst.errno != errno.ENOENT: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
599 raise |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
600 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
601 wlock = self.wlock() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
602 for f in list: |
| 244 | 603 p = self.wjoin(f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
604 if os.path.exists(p): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
605 self.ui.warn(_("%s still exists!\n") % f) |
| 402 | 606 elif self.dirstate.state(f) == 'a': |
|
657
22bc6fb9aefc
dirstate.forget() takes a list
Matt Mackall <mpm@selenic.com>
parents:
656
diff
changeset
|
607 self.dirstate.forget([f]) |
| 220 | 608 elif f not in self.dirstate: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
609 self.ui.warn(_("%s not tracked!\n") % f) |
| 220 | 610 else: |
| 611 self.dirstate.update([f], "r") | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
612 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
613 def undelete(self, list, wlock=None): |
|
1448
182879d71922
Allow reverting a deleted file with two parents
Matt Mackall <mpm@selenic.com>
parents:
1447
diff
changeset
|
614 p = self.dirstate.parents()[0] |
|
1447
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
615 mn = self.changelog.read(p)[0] |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
616 mf = self.manifest.readflags(mn) |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
617 m = self.manifest.read(mn) |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
618 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
619 wlock = self.wlock() |
|
1447
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
620 for f in list: |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
621 if self.dirstate.state(f) not in "r": |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
622 self.ui.warn("%s not removed!\n" % f) |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
623 else: |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
624 t = self.file(f).read(m[f]) |
|
1477
d3566eda2bcb
util.opener already create the base directory if it doesn't exist
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1473
diff
changeset
|
625 self.wwrite(f, t) |
|
1447
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
626 util.set_exec(self.wjoin(f), mf[f]) |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
627 self.dirstate.update([f], "n") |
|
508a3f559553
revert added and removed files to their normal state before reverting
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1427
diff
changeset
|
628 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
629 def copy(self, source, dest, wlock=None): |
| 363 | 630 p = self.wjoin(dest) |
| 781 | 631 if not os.path.exists(p): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
632 self.ui.warn(_("%s does not exist!\n") % dest) |
| 781 | 633 elif not os.path.isfile(p): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
634 self.ui.warn(_("copy failed: %s is not a file\n") % dest) |
| 363 | 635 else: |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
636 if not wlock: |
|
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
637 wlock = self.wlock() |
| 363 | 638 if self.dirstate.state(dest) == '?': |
| 639 self.dirstate.update([dest], "a") | |
| 640 self.dirstate.copy(source, dest) | |
| 641 | |
|
1551
e793cbc8be00
Fixes to "hg heads -r FOO":
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1550
diff
changeset
|
642 def heads(self, start=None): |
|
1550
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
643 heads = self.changelog.heads(start) |
|
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
644 # sort the output in rev descending order |
|
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
645 heads = [(-self.changelog.rev(h), h) for h in heads] |
|
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
646 heads.sort() |
|
ccb9b62de892
add a -r/--rev option to heads to show only heads descendant from rev
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1532
diff
changeset
|
647 return [n for (r, n) in heads] |
| 222 | 648 |
| 898 | 649 # branchlookup returns a dict giving a list of branches for |
| 650 # each head. A branch is defined as the tag of a node or | |
| 651 # the branch of the node's parents. If a node has multiple | |
| 652 # branch tags, tags are eliminated if they are visible from other | |
| 653 # branch tags. | |
| 654 # | |
| 655 # So, for this graph: a->b->c->d->e | |
| 656 # \ / | |
| 657 # aa -----/ | |
| 919 | 658 # a has tag 2.6.12 |
| 898 | 659 # d has tag 2.6.13 |
| 660 # e would have branch tags for 2.6.12 and 2.6.13. Because the node | |
| 661 # for 2.6.12 can be reached from the node 2.6.13, that is eliminated | |
| 662 # from the list. | |
| 663 # | |
| 664 # It is possible that more than one head will have the same branch tag. | |
| 665 # callers need to check the result for multiple heads under the same | |
| 666 # branch tag if that is a problem for them (ie checkout of a specific | |
| 667 # branch). | |
| 668 # | |
| 669 # passing in a specific branch will limit the depth of the search | |
| 670 # through the parents. It won't limit the branches returned in the | |
| 671 # result though. | |
| 672 def branchlookup(self, heads=None, branch=None): | |
| 673 if not heads: | |
| 674 heads = self.heads() | |
| 675 headt = [ h for h in heads ] | |
| 676 chlog = self.changelog | |
| 677 branches = {} | |
| 678 merges = [] | |
| 679 seenmerge = {} | |
| 680 | |
| 681 # traverse the tree once for each head, recording in the branches | |
| 682 # dict which tags are visible from this head. The branches | |
| 683 # dict also records which tags are visible from each tag | |
| 684 # while we traverse. | |
| 685 while headt or merges: | |
| 686 if merges: | |
| 687 n, found = merges.pop() | |
| 688 visit = [n] | |
| 689 else: | |
| 690 h = headt.pop() | |
| 691 visit = [h] | |
| 692 found = [h] | |
| 693 seen = {} | |
| 694 while visit: | |
| 695 n = visit.pop() | |
| 696 if n in seen: | |
| 697 continue | |
| 698 pp = chlog.parents(n) | |
| 699 tags = self.nodetags(n) | |
| 700 if tags: | |
| 701 for x in tags: | |
| 702 if x == 'tip': | |
| 703 continue | |
| 704 for f in found: | |
| 705 branches.setdefault(f, {})[n] = 1 | |
| 706 branches.setdefault(n, {})[n] = 1 | |
| 707 break | |
| 708 if n not in found: | |
| 709 found.append(n) | |
| 710 if branch in tags: | |
| 711 continue | |
| 712 seen[n] = 1 | |
| 713 if pp[1] != nullid and n not in seenmerge: | |
| 714 merges.append((pp[1], [x for x in found])) | |
| 715 seenmerge[n] = 1 | |
| 716 if pp[0] != nullid: | |
| 717 visit.append(pp[0]) | |
| 718 # traverse the branches dict, eliminating branch tags from each | |
| 719 # head that are visible from another branch tag for that head. | |
| 720 out = {} | |
| 721 viscache = {} | |
| 722 for h in heads: | |
| 723 def visible(node): | |
| 724 if node in viscache: | |
| 725 return viscache[node] | |
| 726 ret = {} | |
| 727 visit = [node] | |
| 728 while visit: | |
| 729 x = visit.pop() | |
| 730 if x in viscache: | |
| 731 ret.update(viscache[x]) | |
| 732 elif x not in ret: | |
| 733 ret[x] = 1 | |
| 734 if x in branches: | |
| 735 visit[len(visit):] = branches[x].keys() | |
| 736 viscache[node] = ret | |
| 737 return ret | |
| 738 if h not in branches: | |
| 739 continue | |
| 740 # O(n^2), but somewhat limited. This only searches the | |
| 741 # tags visible from a specific head, not all the tags in the | |
| 742 # whole repo. | |
| 743 for b in branches[h]: | |
| 744 vis = False | |
| 745 for bb in branches[h].keys(): | |
| 746 if b != bb: | |
| 747 if b in visible(bb): | |
| 748 vis = True | |
| 749 break | |
| 750 if not vis: | |
| 751 l = out.setdefault(h, []) | |
| 752 l[len(l):] = self.nodetags(b) | |
| 753 return out | |
| 754 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
755 def branches(self, nodes): |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
756 if not nodes: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
757 nodes = [self.changelog.tip()] |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
758 b = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
759 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
760 t = n |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
761 while n: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
762 p = self.changelog.parents(n) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
763 if p[1] != nullid or p[0] == nullid: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
764 b.append((t, n, p[0], p[1])) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
765 break |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
766 n = p[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
767 return b |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
768 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
769 def between(self, pairs): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
770 r = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
771 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
772 for top, bottom in pairs: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
773 n, l, i = top, [], 0 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
774 f = 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
775 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
776 while n != bottom: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
777 p = self.changelog.parents(n)[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
778 if i == f: |
| 575 | 779 l.append(n) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
780 f = f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
781 n = p |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
782 i += 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
783 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
784 r.append(l) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
785 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
786 return r |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
787 |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
788 def findincoming(self, remote, base=None, heads=None, force=False): |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
789 m = self.changelog.nodemap |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
790 search = [] |
| 1072 | 791 fetch = {} |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
792 seen = {} |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
793 seenbranch = {} |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
794 if base == None: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
795 base = {} |
| 192 | 796 |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
797 # assume we're closer to the tip than the root |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
798 # and start by examining the heads |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
799 self.ui.status(_("searching for changes\n")) |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
800 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
801 if not heads: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
802 heads = remote.heads() |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
803 |
| 222 | 804 unknown = [] |
| 805 for h in heads: | |
| 806 if h not in m: | |
| 807 unknown.append(h) | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
808 else: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
809 base[h] = 1 |
| 46 | 810 |
| 222 | 811 if not unknown: |
|
1895
d7c038e805e9
findincoming should return an iterable
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
812 return [] |
| 324 | 813 |
| 814 rep = {} | |
| 815 reqcnt = 0 | |
| 515 | 816 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
817 # search through remote branches |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
818 # a 'branch' here is a linear segment of history, with four parts: |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
819 # head, root, first parent, second parent |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
820 # (a branch always has two parents (or none) by definition) |
| 222 | 821 unknown = remote.branches(unknown) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
822 while unknown: |
| 324 | 823 r = [] |
| 824 while unknown: | |
| 825 n = unknown.pop(0) | |
| 826 if n[0] in seen: | |
| 827 continue | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
828 |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
829 self.ui.debug(_("examining %s:%s\n") |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
830 % (short(n[0]), short(n[1]))) |
| 324 | 831 if n[0] == nullid: |
| 832 break | |
| 328 | 833 if n in seenbranch: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
834 self.ui.debug(_("branch already found\n")) |
| 324 | 835 continue |
| 836 if n[1] and n[1] in m: # do we know the base? | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
837 self.ui.debug(_("found incomplete branch %s:%s\n") |
| 324 | 838 % (short(n[0]), short(n[1]))) |
| 839 search.append(n) # schedule branch range for scanning | |
| 328 | 840 seenbranch[n] = 1 |
| 324 | 841 else: |
| 842 if n[1] not in seen and n[1] not in fetch: | |
| 843 if n[2] in m and n[3] in m: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
844 self.ui.debug(_("found new changeset %s\n") % |
| 324 | 845 short(n[1])) |
| 1072 | 846 fetch[n[1]] = 1 # earliest unknown |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
847 base[n[2]] = 1 # latest known |
| 324 | 848 continue |
| 849 | |
| 850 for a in n[2:4]: | |
| 851 if a not in rep: | |
| 852 r.append(a) | |
| 853 rep[a] = 1 | |
| 854 | |
| 328 | 855 seen[n[0]] = 1 |
| 856 | |
| 324 | 857 if r: |
| 858 reqcnt += 1 | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
859 self.ui.debug(_("request %d: %s\n") % |
| 324 | 860 (reqcnt, " ".join(map(short, r)))) |
| 861 for p in range(0, len(r), 10): | |
| 862 for b in remote.branches(r[p:p+10]): | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
863 self.ui.debug(_("received %s:%s\n") % |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
864 (short(b[0]), short(b[1]))) |
| 1072 | 865 if b[0] in m: |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
866 self.ui.debug(_("found base node %s\n") |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
867 % short(b[0])) |
| 1072 | 868 base[b[0]] = 1 |
| 869 elif b[0] not in seen: | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
870 unknown.append(b) |
| 515 | 871 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
872 # do binary search on the branches we found |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
873 while search: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
874 n = search.pop(0) |
| 324 | 875 reqcnt += 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
876 l = remote.between([(n[0], n[1])])[0] |
| 328 | 877 l.append(n[1]) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
878 p = n[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
879 f = 1 |
| 328 | 880 for i in l: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
881 self.ui.debug(_("narrowing %d:%d %s\n") % (f, len(l), short(i))) |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
882 if i in m: |
| 85 | 883 if f <= 2: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
884 self.ui.debug(_("found new branch changeset %s\n") % |
| 83 | 885 short(p)) |
| 1072 | 886 fetch[p] = 1 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
887 base[i] = 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
888 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
889 self.ui.debug(_("narrowed branch search to %s:%s\n") |
| 83 | 890 % (short(p), short(i))) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
891 search.append((p, i)) |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
892 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
893 p, f = i, f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
894 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
895 # sanity check our fetch list |
| 1072 | 896 for f in fetch.keys(): |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
897 if f in m: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
898 raise repo.RepoError(_("already have changeset ") + short(f[:4])) |
| 83 | 899 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
900 if base.keys() == [nullid]: |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
901 if force: |
|
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
902 self.ui.warn(_("warning: repository is unrelated\n")) |
|
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
903 else: |
|
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
904 raise util.Abort(_("repository is unrelated")) |
| 511 | 905 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
906 self.ui.note(_("found new changesets starting at ") + |
| 83 | 907 " ".join([short(f) for f in fetch]) + "\n") |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
908 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
909 self.ui.debug(_("%d total queries\n") % reqcnt) |
| 324 | 910 |
| 1072 | 911 return fetch.keys() |
| 516 | 912 |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
913 def findoutgoing(self, remote, base=None, heads=None, force=False): |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
914 if base == None: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
915 base = {} |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
916 self.findincoming(remote, base, heads, force=force) |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
917 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
918 self.ui.debug(_("common changesets up to ") |
| 1072 | 919 + " ".join(map(short, base.keys())) + "\n") |
| 920 | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
921 remain = dict.fromkeys(self.changelog.nodemap) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
922 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
923 # prune everything remote has from the tree |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
924 del remain[nullid] |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
925 remove = base.keys() |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
926 while remove: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
927 n = remove.pop(0) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
928 if n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
929 del remain[n] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
930 for p in self.changelog.parents(n): |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
931 remove.append(p) |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
932 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
933 # find every node whose parents have been pruned |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
934 subset = [] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
935 for n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
936 p1, p2 = self.changelog.parents(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
937 if p1 not in remain and p2 not in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
938 subset.append(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
939 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
940 # this is the set of all roots we have to push |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
941 return subset |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
942 |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
943 def pull(self, remote, heads=None, force=False): |
|
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1747
diff
changeset
|
944 l = self.lock() |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
945 |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
946 # if we have an empty repo, fetch everything |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
947 if self.changelog.tip() == nullid: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
948 self.ui.status(_("requesting all changes\n")) |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
949 fetch = [nullid] |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
950 else: |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
951 fetch = self.findincoming(remote, force=force) |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
952 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
953 if not fetch: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
954 self.ui.status(_("no changes found\n")) |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
955 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
956 |
|
1461
02099220ad49
Implementing clone -r, which clones all changesets needed to reach a
Eric Hopper <hopper@omnifarious.org>
parents:
1460
diff
changeset
|
957 if heads is None: |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
958 cg = remote.changegroup(fetch, 'pull') |
|
1461
02099220ad49
Implementing clone -r, which clones all changesets needed to reach a
Eric Hopper <hopper@omnifarious.org>
parents:
1460
diff
changeset
|
959 else: |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
960 cg = remote.changegroupsubset(fetch, heads, 'pull') |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
961 return self.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
962 |
|
1781
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
963 def push(self, remote, force=False, revs=None): |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
964 lock = remote.lock() |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
965 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
966 base = {} |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
967 heads = remote.heads() |
|
1959
d53a18f592be
add -f/--force to pull, incoming, outgoing, to work on unrelated repo.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1947
diff
changeset
|
968 inc = self.findincoming(remote, base, heads, force=force) |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
969 if not force and inc: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
970 self.ui.warn(_("abort: unsynced remote changes!\n")) |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
971 self.ui.status(_("(did you forget to sync? use push -f to force)\n")) |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
972 return 1 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
973 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
974 update = self.findoutgoing(remote, base) |
|
1781
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
975 if revs is not None: |
|
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
976 msng_cl, bases, heads = self.changelog.nodesbetween(update, revs) |
|
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
977 else: |
|
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
978 bases, heads = update, self.changelog.heads() |
|
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
979 |
|
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
980 if not bases: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
981 self.ui.status(_("no changes found\n")) |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
982 return 1 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
983 elif not force: |
|
1781
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
984 if len(bases) < len(heads): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
985 self.ui.warn(_("abort: push creates new remote branches!\n")) |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
986 self.ui.status(_("(did you forget to merge?" |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
987 " use push -f to force)\n")) |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
988 return 1 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
989 |
|
1781
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
990 if revs is None: |
| 1782 | 991 cg = self.changegroup(update, 'push') |
|
1781
284fc722c342
add an optional argument to push only the specified revisions (push -r)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1713
diff
changeset
|
992 else: |
| 1782 | 993 cg = self.changegroupsubset(update, revs, 'push') |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
994 return remote.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
995 |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
996 def changegroupsubset(self, bases, heads, source): |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
997 """This function generates a changegroup consisting of all the nodes |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
998 that are descendents of any of the bases, and ancestors of any of |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
999 the heads. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1000 |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1001 It is fairly complex as determining which filenodes and which |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1002 manifest nodes need to be included for the changeset to be complete |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1003 is non-trivial. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1004 |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1005 Another wrinkle is doing the reverse, figuring out which changeset in |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1006 the changegroup a particular filenode or manifestnode belongs to.""" |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1007 |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1008 self.hook('preoutgoing', throw=True, source=source) |
|
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1009 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1010 # Set up some initial variables |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1011 # Make it easy to refer to self.changelog |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1012 cl = self.changelog |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1013 # msng is short for missing - compute the list of changesets in this |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1014 # changegroup. |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1015 msng_cl_lst, bases, heads = cl.nodesbetween(bases, heads) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1016 # Some bases may turn out to be superfluous, and some heads may be |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1017 # too. nodesbetween will return the minimal set of bases and heads |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1018 # necessary to re-create the changegroup. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1019 |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1020 # Known heads are the list of heads that it is assumed the recipient |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1021 # of this changegroup will know about. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1022 knownheads = {} |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1023 # We assume that all parents of bases are known heads. |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1024 for n in bases: |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1025 for p in cl.parents(n): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1026 if p != nullid: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1027 knownheads[p] = 1 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1028 knownheads = knownheads.keys() |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1029 if knownheads: |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1030 # Now that we know what heads are known, we can compute which |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1031 # changesets are known. The recipient must know about all |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1032 # changesets required to reach the known heads from the null |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1033 # changeset. |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1034 has_cl_set, junk, junk = cl.nodesbetween(None, knownheads) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1035 junk = None |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1036 # Transform the list into an ersatz set. |
|
1464
00117edce2dd
Fixed silly bug involving a non-existent variable.
Eric Hopper <hopper@omnifarious.org>
parents:
1462
diff
changeset
|
1037 has_cl_set = dict.fromkeys(has_cl_set) |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1038 else: |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1039 # If there were no known heads, the recipient cannot be assumed to |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1040 # know about any changesets. |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1041 has_cl_set = {} |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1042 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1043 # Make it easy to refer to self.manifest |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1044 mnfst = self.manifest |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1045 # We don't know which manifests are missing yet |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1046 msng_mnfst_set = {} |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1047 # Nor do we know which filenodes are missing. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1048 msng_filenode_set = {} |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1049 |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1050 junk = mnfst.index[mnfst.count() - 1] # Get around a bug in lazyindex |
|
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1051 junk = None |
|
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1052 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1053 # A changeset always belongs to itself, so the changenode lookup |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1054 # function for a changenode is identity. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1055 def identity(x): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1056 return x |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1057 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1058 # A function generating function. Sets up an environment for the |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1059 # inner function. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1060 def cmp_by_rev_func(revlog): |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1061 # Compare two nodes by their revision number in the environment's |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1062 # revision history. Since the revision number both represents the |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1063 # most efficient order to read the nodes in, and represents a |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1064 # topological sorting of the nodes, this function is often useful. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1065 def cmp_by_rev(a, b): |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1066 return cmp(revlog.rev(a), revlog.rev(b)) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1067 return cmp_by_rev |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1068 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1069 # If we determine that a particular file or manifest node must be a |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1070 # node that the recipient of the changegroup will already have, we can |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1071 # also assume the recipient will have all the parents. This function |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1072 # prunes them from the set of missing nodes. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1073 def prune_parents(revlog, hasset, msngset): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1074 haslst = hasset.keys() |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1075 haslst.sort(cmp_by_rev_func(revlog)) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1076 for node in haslst: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1077 parentlst = [p for p in revlog.parents(node) if p != nullid] |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1078 while parentlst: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1079 n = parentlst.pop() |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1080 if n not in hasset: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1081 hasset[n] = 1 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1082 p = [p for p in revlog.parents(n) if p != nullid] |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1083 parentlst.extend(p) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1084 for n in hasset: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1085 msngset.pop(n, None) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1086 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1087 # This is a function generating function used to set up an environment |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1088 # for the inner function to execute in. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1089 def manifest_and_file_collector(changedfileset): |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1090 # This is an information gathering function that gathers |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1091 # information from each changeset node that goes out as part of |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1092 # the changegroup. The information gathered is a list of which |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1093 # manifest nodes are potentially required (the recipient may |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1094 # already have them) and total list of all files which were |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1095 # changed in any changeset in the changegroup. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1096 # |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1097 # We also remember the first changenode we saw any manifest |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1098 # referenced by so we can later determine which changenode 'owns' |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1099 # the manifest. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1100 def collect_manifests_and_files(clnode): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1101 c = cl.read(clnode) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1102 for f in c[3]: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1103 # This is to make sure we only have one instance of each |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1104 # filename string for each filename. |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1105 changedfileset.setdefault(f, f) |
|
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1106 msng_mnfst_set.setdefault(c[0], clnode) |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1107 return collect_manifests_and_files |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1108 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1109 # Figure out which manifest nodes (of the ones we think might be part |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1110 # of the changegroup) the recipient must know about and remove them |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1111 # from the changegroup. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1112 def prune_manifests(): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1113 has_mnfst_set = {} |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1114 for n in msng_mnfst_set: |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1115 # If a 'missing' manifest thinks it belongs to a changenode |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1116 # the recipient is assumed to have, obviously the recipient |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1117 # must have that manifest. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1118 linknode = cl.node(mnfst.linkrev(n)) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1119 if linknode in has_cl_set: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1120 has_mnfst_set[n] = 1 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1121 prune_parents(mnfst, has_mnfst_set, msng_mnfst_set) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1122 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1123 # Use the information collected in collect_manifests_and_files to say |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1124 # which changenode any manifestnode belongs to. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1125 def lookup_manifest_link(mnfstnode): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1126 return msng_mnfst_set[mnfstnode] |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1127 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1128 # A function generating function that sets up the initial environment |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1129 # the inner function. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1130 def filenode_collector(changedfiles): |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1131 next_rev = [0] |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1132 # This gathers information from each manifestnode included in the |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1133 # changegroup about which filenodes the manifest node references |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1134 # so we can include those in the changegroup too. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1135 # |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1136 # It also remembers which changenode each filenode belongs to. It |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1137 # does this by assuming the a filenode belongs to the changenode |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1138 # the first manifest that references it belongs to. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1139 def collect_msng_filenodes(mnfstnode): |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1140 r = mnfst.rev(mnfstnode) |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1141 if r == next_rev[0]: |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1142 # If the last rev we looked at was the one just previous, |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1143 # we only need to see a diff. |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1144 delta = mdiff.patchtext(mnfst.delta(mnfstnode)) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1145 # For each line in the delta |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1146 for dline in delta.splitlines(): |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1147 # get the filename and filenode for that line |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1148 f, fnode = dline.split('\0') |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1149 fnode = bin(fnode[:40]) |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1150 f = changedfiles.get(f, None) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1151 # And if the file is in the list of files we care |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1152 # about. |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1153 if f is not None: |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1154 # Get the changenode this manifest belongs to |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1155 clnode = msng_mnfst_set[mnfstnode] |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1156 # Create the set of filenodes for the file if |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1157 # there isn't one already. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1158 ndset = msng_filenode_set.setdefault(f, {}) |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1159 # And set the filenode's changelog node to the |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1160 # manifest's if it hasn't been set already. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1161 ndset.setdefault(fnode, clnode) |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1162 else: |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1163 # Otherwise we need a full manifest. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1164 m = mnfst.read(mnfstnode) |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1165 # For every file in we care about. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1166 for f in changedfiles: |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1167 fnode = m.get(f, None) |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1168 # If it's in the manifest |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1169 if fnode is not None: |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1170 # See comments above. |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1171 clnode = msng_mnfst_set[mnfstnode] |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1172 ndset = msng_filenode_set.setdefault(f, {}) |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1173 ndset.setdefault(fnode, clnode) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1174 # Remember the revision we hope to see next. |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1175 next_rev[0] = r + 1 |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1176 return collect_msng_filenodes |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1177 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1178 # We have a list of filenodes we think we need for a file, lets remove |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1179 # all those we now the recipient must have. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1180 def prune_filenodes(f, filerevlog): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1181 msngset = msng_filenode_set[f] |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1182 hasset = {} |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1183 # If a 'missing' filenode thinks it belongs to a changenode we |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1184 # assume the recipient must have, then the recipient must have |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1185 # that filenode. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1186 for n in msngset: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1187 clnode = cl.node(filerevlog.linkrev(n)) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1188 if clnode in has_cl_set: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1189 hasset[n] = 1 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1190 prune_parents(filerevlog, hasset, msngset) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1191 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1192 # A function generator function that sets up the a context for the |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1193 # inner function. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1194 def lookup_filenode_link_func(fname): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1195 msngset = msng_filenode_set[fname] |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1196 # Lookup the changenode the filenode belongs to. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1197 def lookup_filenode_link(fnode): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1198 return msngset[fnode] |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1199 return lookup_filenode_link |
| 515 | 1200 |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1201 # Now that we have all theses utility functions to help out and |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1202 # logically divide up the task, generate the group. |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1203 def gengroup(): |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1204 # The set of changed files starts empty. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1205 changedfiles = {} |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1206 # Create a changenode group generator that will call our functions |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1207 # back to lookup the owning changenode and collect information. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1208 group = cl.group(msng_cl_lst, identity, |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1209 manifest_and_file_collector(changedfiles)) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1210 for chnk in group: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1211 yield chnk |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1212 |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1213 # The list of manifests has been collected by the generator |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1214 # calling our functions back. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1215 prune_manifests() |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1216 msng_mnfst_lst = msng_mnfst_set.keys() |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1217 # Sort the manifestnodes by revision number. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1218 msng_mnfst_lst.sort(cmp_by_rev_func(mnfst)) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1219 # Create a generator for the manifestnodes that calls our lookup |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1220 # and data collection functions back. |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1221 group = mnfst.group(msng_mnfst_lst, lookup_manifest_link, |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1222 filenode_collector(changedfiles)) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1223 for chnk in group: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1224 yield chnk |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1225 |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1226 # These are no longer needed, dereference and toss the memory for |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1227 # them. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1228 msng_mnfst_lst = None |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1229 msng_mnfst_set.clear() |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1230 |
|
1462
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1231 changedfiles = changedfiles.keys() |
|
12a8d772fa32
Optimizing manifest reads in changegroupsubset by using deltas.
Eric Hopper <hopper@omnifarious.org>
parents:
1461
diff
changeset
|
1232 changedfiles.sort() |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1233 # Go through all our files in order sorted by name. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1234 for fname in changedfiles: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1235 filerevlog = self.file(fname) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1236 # Toss out the filenodes that the recipient isn't really |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1237 # missing. |
|
1630
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1238 if msng_filenode_set.has_key(fname): |
|
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1239 prune_filenodes(fname, filerevlog) |
|
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1240 msng_filenode_lst = msng_filenode_set[fname].keys() |
|
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1241 else: |
|
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1242 msng_filenode_lst = [] |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1243 # If any filenodes are left, generate the group for them, |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1244 # otherwise don't bother. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1245 if len(msng_filenode_lst) > 0: |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1246 yield struct.pack(">l", len(fname) + 4) + fname |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1247 # Sort the filenodes by their revision # |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1248 msng_filenode_lst.sort(cmp_by_rev_func(filerevlog)) |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1249 # Create a group generator and only pass in a changenode |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1250 # lookup function as we need to collect no information |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1251 # from filenodes. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1252 group = filerevlog.group(msng_filenode_lst, |
|
1460
40d08cf1c544
Bug fixing in localrepository.changegroupsubset. Bugs found in testing.
Eric Hopper <hopper@omnifarious.org>
parents:
1458
diff
changeset
|
1253 lookup_filenode_link_func(fname)) |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1254 for chnk in group: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1255 yield chnk |
|
1630
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1256 if msng_filenode_set.has_key(fname): |
|
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1257 # Don't need this anymore, toss it to free memory. |
|
5ecf05541e11
This fixes a bug that Chris Mason found. As for a test case, I can't
Eric Hopper <hopper@omnifarious.org>
parents:
1621
diff
changeset
|
1258 del msng_filenode_set[fname] |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1259 # Signal that no more groups are left. |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1260 yield struct.pack(">l", 0) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1261 |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1262 self.hook('outgoing', node=hex(msng_cl_lst[0]), source=source) |
|
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1263 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1264 return util.chunkbuffer(gengroup()) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1265 |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1266 def changegroup(self, basenodes, source): |
|
1466
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1267 """Generate a changegroup of all nodes that we have that a recipient |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1268 doesn't. |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1269 |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1270 This is much easier than the previous function as we can assume that |
|
b6d9ea0bc107
Added a lot of comments to changegroupsubset.
Eric Hopper <hopper@omnifarious.org>
parents:
1464
diff
changeset
|
1271 the recipient has any changenode we aren't sending them.""" |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1272 |
|
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1273 self.hook('preoutgoing', throw=True, source=source) |
|
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1274 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1275 cl = self.changelog |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1276 nodes = cl.nodesbetween(basenodes, None)[0] |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1277 revset = dict.fromkeys([cl.rev(n) for n in nodes]) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1278 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1279 def identity(x): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1280 return x |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1281 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1282 def gennodelst(revlog): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1283 for r in xrange(0, revlog.count()): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1284 n = revlog.node(r) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1285 if revlog.linkrev(n) in revset: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1286 yield n |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1287 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1288 def changed_file_collector(changedfileset): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1289 def collect_changed_files(clnode): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1290 c = cl.read(clnode) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1291 for fname in c[3]: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1292 changedfileset[fname] = 1 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1293 return collect_changed_files |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1294 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1295 def lookuprevlink_func(revlog): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1296 def lookuprevlink(n): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1297 return cl.node(revlog.linkrev(n)) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1298 return lookuprevlink |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1299 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1300 def gengroup(): |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1301 # construct a list of all changed files |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1302 changedfiles = {} |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1303 |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1304 for chnk in cl.group(nodes, identity, |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1305 changed_file_collector(changedfiles)): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1306 yield chnk |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1307 changedfiles = changedfiles.keys() |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1308 changedfiles.sort() |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1309 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1310 mnfst = self.manifest |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1311 nodeiter = gennodelst(mnfst) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1312 for chnk in mnfst.group(nodeiter, lookuprevlink_func(mnfst)): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1313 yield chnk |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1314 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1315 for fname in changedfiles: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1316 filerevlog = self.file(fname) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1317 nodeiter = gennodelst(filerevlog) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1318 nodeiter = list(nodeiter) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1319 if nodeiter: |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1320 yield struct.pack(">l", len(fname) + 4) + fname |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1321 lookup = lookuprevlink_func(filerevlog) |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1322 for chnk in filerevlog.group(nodeiter, lookup): |
|
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1323 yield chnk |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1324 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1325 yield struct.pack(">l", 0) |
|
1736
50de0887bbcd
add preoutgoing and outgoing hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1732
diff
changeset
|
1326 self.hook('outgoing', node=hex(nodes[0]), source=source) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1327 |
|
1458
1033892bbb87
This changes the revlog.group and re-implements the localrepo.changeroup
Eric Hopper <hopper@omnifarious.org>
parents:
1457
diff
changeset
|
1328 return util.chunkbuffer(gengroup()) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1329 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1330 def addchangegroup(self, source): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1331 |
| 222 | 1332 def getchunk(): |
| 1333 d = source.read(4) | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1334 if not d: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1335 return "" |
| 222 | 1336 l = struct.unpack(">l", d)[0] |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1337 if l <= 4: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1338 return "" |
|
1280
50553b99a5c9
pull/unbundle: raise an exception on premature EOF
mpm@selenic.com
parents:
1260
diff
changeset
|
1339 d = source.read(l - 4) |
|
50553b99a5c9
pull/unbundle: raise an exception on premature EOF
mpm@selenic.com
parents:
1260
diff
changeset
|
1340 if len(d) < l - 4: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1341 raise repo.RepoError(_("premature EOF reading chunk" |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1342 " (got %d bytes, expected %d)") |
|
1280
50553b99a5c9
pull/unbundle: raise an exception on premature EOF
mpm@selenic.com
parents:
1260
diff
changeset
|
1343 % (len(d), l - 4)) |
|
50553b99a5c9
pull/unbundle: raise an exception on premature EOF
mpm@selenic.com
parents:
1260
diff
changeset
|
1344 return d |
| 222 | 1345 |
| 1346 def getgroup(): | |
| 1347 while 1: | |
| 1348 c = getchunk() | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1349 if not c: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1350 break |
| 222 | 1351 yield c |
| 1352 | |
| 1353 def csmap(x): | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1354 self.ui.debug(_("add changeset %s\n") % short(x)) |
| 222 | 1355 return self.changelog.count() |
| 1356 | |
| 1357 def revmap(x): | |
| 1358 return self.changelog.rev(x) | |
| 1359 | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1360 if not source: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1361 return |
|
1730
0f1d2c75db5e
add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1721
diff
changeset
|
1362 |
|
0f1d2c75db5e
add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1721
diff
changeset
|
1363 self.hook('prechangegroup', throw=True) |
|
0f1d2c75db5e
add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1721
diff
changeset
|
1364 |
| 222 | 1365 changesets = files = revisions = 0 |
| 225 | 1366 |
| 222 | 1367 tr = self.transaction() |
| 1368 | |
|
1040
35e883d1ff9b
Show number of new heads when doing a pull
mpm@selenic.com
parents:
1019
diff
changeset
|
1369 oldheads = len(self.changelog.heads()) |
|
35e883d1ff9b
Show number of new heads when doing a pull
mpm@selenic.com
parents:
1019
diff
changeset
|
1370 |
| 222 | 1371 # pull off the changeset group |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1372 self.ui.status(_("adding changesets\n")) |
| 222 | 1373 co = self.changelog.tip() |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
223
diff
changeset
|
1374 cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique |
| 1316 | 1375 cnr, cor = map(self.changelog.rev, (cn, co)) |
|
1375
f2b00be33e2c
Fix traceback when nothing was added during unbundle
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1353
diff
changeset
|
1376 if cn == nullid: |
|
f2b00be33e2c
Fix traceback when nothing was added during unbundle
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1353
diff
changeset
|
1377 cnr = cor |
| 1316 | 1378 changesets = cnr - cor |
| 222 | 1379 |
| 1380 # pull off the manifest group | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1381 self.ui.status(_("adding manifests\n")) |
| 222 | 1382 mm = self.manifest.tip() |
| 1383 mo = self.manifest.addgroup(getgroup(), revmap, tr) | |
| 1384 | |
| 1385 # process the files | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1386 self.ui.status(_("adding file changes\n")) |
| 222 | 1387 while 1: |
| 1388 f = getchunk() | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1389 if not f: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1390 break |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1391 self.ui.debug(_("adding %s revisions\n") % f) |
| 222 | 1392 fl = self.file(f) |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1393 o = fl.count() |
| 222 | 1394 n = fl.addgroup(getgroup(), revmap, tr) |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1395 revisions += fl.count() - o |
| 222 | 1396 files += 1 |
| 1397 | |
|
1040
35e883d1ff9b
Show number of new heads when doing a pull
mpm@selenic.com
parents:
1019
diff
changeset
|
1398 newheads = len(self.changelog.heads()) |
|
35e883d1ff9b
Show number of new heads when doing a pull
mpm@selenic.com
parents:
1019
diff
changeset
|
1399 heads = "" |
|
35e883d1ff9b
Show number of new heads when doing a pull
mpm@selenic.com
parents:
1019
diff
changeset
|
1400 if oldheads and newheads > oldheads: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1401 heads = _(" (+%d heads)") % (newheads - oldheads) |
|
1040
35e883d1ff9b
Show number of new heads when doing a pull
mpm@selenic.com
parents:
1019
diff
changeset
|
1402 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1403 self.ui.status(_("added %d changesets" |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1404 " with %d changes to %d files%s\n") |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1405 % (changesets, revisions, files, heads)) |
| 222 | 1406 |
|
1730
0f1d2c75db5e
add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1721
diff
changeset
|
1407 self.hook('pretxnchangegroup', throw=True, |
|
0f1d2c75db5e
add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1721
diff
changeset
|
1408 node=hex(self.changelog.node(cor+1))) |
|
0f1d2c75db5e
add prechangegroup and pretxnchangegroup hooks.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1721
diff
changeset
|
1409 |
| 222 | 1410 tr.close() |
| 780 | 1411 |
|
1375
f2b00be33e2c
Fix traceback when nothing was added during unbundle
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1353
diff
changeset
|
1412 if changesets > 0: |
|
1717
7a4a16a7d21f
hooks run after transactions finish must not affect method results.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1713
diff
changeset
|
1413 self.hook("changegroup", node=hex(self.changelog.node(cor+1))) |
| 780 | 1414 |
|
1375
f2b00be33e2c
Fix traceback when nothing was added during unbundle
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1353
diff
changeset
|
1415 for i in range(cor + 1, cnr + 1): |
|
1713
03ee100b8c21
hooks: distinguish between locally committed and incoming changes.
Daniel Santa Cruz <byteshack@gmail.com>
parents:
1712
diff
changeset
|
1416 self.hook("incoming", node=hex(self.changelog.node(i))) |
| 1316 | 1417 |
| 588 | 1418 def update(self, node, allow=False, force=False, choose=None, |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
1419 moddirstate=True, forcemerge=False, wlock=None): |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1420 pl = self.dirstate.parents() |
| 275 | 1421 if not force and pl[1] != nullid: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1422 self.ui.warn(_("aborting: outstanding uncommitted merges\n")) |
| 690 | 1423 return 1 |
| 46 | 1424 |
|
1663
d529cdc0a3ee
return a non-zero exit code when a merge failed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1645
diff
changeset
|
1425 err = False |
|
d529cdc0a3ee
return a non-zero exit code when a merge failed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1645
diff
changeset
|
1426 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1427 p1, p2 = pl[0], node |
| 305 | 1428 pa = self.changelog.ancestor(p1, p2) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1429 m1n = self.changelog.read(p1)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1430 m2n = self.changelog.read(p2)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1431 man = self.manifest.ancestor(m1n, m2n) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1432 m1 = self.manifest.read(m1n) |
| 276 | 1433 mf1 = self.manifest.readflags(m1n) |
|
1629
3024cacfb2c9
Copy manifest map before modifying it (see issue86)
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1621
diff
changeset
|
1434 m2 = self.manifest.read(m2n).copy() |
| 276 | 1435 mf2 = self.manifest.readflags(m2n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1436 ma = self.manifest.read(man) |
| 412 | 1437 mfa = self.manifest.readflags(man) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1438 |
|
1619
1ba0d7041ac4
Distinguish removed and deleted files. Tests are not fixed yet.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1618
diff
changeset
|
1439 modified, added, removed, deleted, unknown = self.changes() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1440 |
|
1674
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1441 # is this a jump, or a merge? i.e. is there a linear path |
|
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1442 # from p1 to p2? |
|
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1443 linear_path = (pa == p1 or pa == p2) |
|
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1444 |
|
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1445 if allow and linear_path: |
|
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1446 raise util.Abort(_("there is nothing to merge, " |
|
dee55c4a4963
abort when using 'update -m' and this is not a merge
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1667
diff
changeset
|
1447 "just use 'hg update'")) |
|
1581
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1448 if allow and not forcemerge: |
|
1618
ff339dd21976
Renamed c, a, d, u to modified, added, removed, unknown for users of changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1617
diff
changeset
|
1449 if modified or added or removed: |
|
1581
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1450 raise util.Abort(_("outstanding uncommited changes")) |
|
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1451 if not forcemerge and not force: |
|
1618
ff339dd21976
Renamed c, a, d, u to modified, added, removed, unknown for users of changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1617
diff
changeset
|
1452 for f in unknown: |
|
1581
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1453 if f in m2: |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1454 t1 = self.wread(f) |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1455 t2 = self.file(f).read(m2[f]) |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1456 if cmp(t1, t2) != 0: |
|
1581
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1457 raise util.Abort(_("'%s' already exists in the working" |
|
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1458 " dir and differs from remote") % f) |
|
db10b7114de0
abort when merging two heads and repository has local changes
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1559
diff
changeset
|
1459 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1460 # resolve the manifest to determine which files |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1461 # we care about merging |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1462 self.ui.note(_("resolving manifests\n")) |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1463 self.ui.debug(_(" force %s allow %s moddirstate %s linear %s\n") % |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1464 (force, allow, moddirstate, linear_path)) |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1465 self.ui.debug(_(" ancestor %s local %s remote %s\n") % |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1466 (short(man), short(m1n), short(m2n))) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1467 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1468 merge = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1469 get = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1470 remove = [] |
| 46 | 1471 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1472 # construct a working dir manifest |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1473 mw = m1.copy() |
| 276 | 1474 mfw = mf1.copy() |
|
1618
ff339dd21976
Renamed c, a, d, u to modified, added, removed, unknown for users of changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1617
diff
changeset
|
1475 umap = dict.fromkeys(unknown) |
| 576 | 1476 |
|
1618
ff339dd21976
Renamed c, a, d, u to modified, added, removed, unknown for users of changes()
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1617
diff
changeset
|
1477 for f in added + modified + unknown: |
| 254 | 1478 mw[f] = "" |
| 441 | 1479 mfw[f] = util.is_exec(self.wjoin(f), mfw.get(f, False)) |
| 576 | 1480 |
|
1712
21dcf38e5d7d
Allow callers to pass in the dirstate lock in most localrepo.py funcs.
mason@suse.com
parents:
1709
diff
changeset
|
1481 if moddirstate and not wlock: |
|
1531
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1482 wlock = self.wlock() |
|
2ba8bf7defda
add localrepo.wlock for protecting the dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1516
diff
changeset
|
1483 |
|
1621
ee16f06174bd
Restored old behaviour for 'hg co' and 'hg co -C' for removed files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1619
diff
changeset
|
1484 for f in deleted + removed: |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1485 if f in mw: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1486 del mw[f] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1487 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1488 # If we're jumping between revisions (as opposed to merging), |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1489 # and if neither the working directory nor the target rev has |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1490 # the file, then we need to remove it from the dirstate, to |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1491 # prevent the dirstate from listing the file when it is no |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1492 # longer in the manifest. |
| 588 | 1493 if moddirstate and linear_path and f not in m2: |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1494 self.dirstate.forget((f,)) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1495 |
| 576 | 1496 # Compare manifests |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1497 for f, n in mw.iteritems(): |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1498 if choose and not choose(f): |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1499 continue |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1500 if f in m2: |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1501 s = 0 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1502 |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1503 # is the wfile new since m1, and match m2? |
| 428 | 1504 if f not in m1: |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
1505 t1 = self.wread(f) |
|
994
88c15682d9b0
Fix callers to file.revision to use file.read
mpm@selenic.com
parents:
993
diff
changeset
|
1506 t2 = self.file(f).read(m2[f]) |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1507 if cmp(t1, t2) == 0: |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1508 n = m2[f] |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1509 del t1, t2 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1510 |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1511 # are files different? |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1512 if n != m2[f]: |
| 254 | 1513 a = ma.get(f, nullid) |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1514 # are both different from the ancestor? |
| 254 | 1515 if n != a and m2[f] != a: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1516 self.ui.debug(_(" %s versions differ, resolve\n") % f) |
| 276 | 1517 # merge executable bits |
| 1518 # "if we changed or they changed, change in merge" | |
| 1519 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] | |
| 1520 mode = ((a^b) | (a^c)) ^ a | |
| 1521 merge[f] = (m1.get(f, nullid), m2[f], mode) | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1522 s = 1 |
| 305 | 1523 # are we clobbering? |
| 1524 # is remote's version newer? | |
| 1525 # or are we going back in time? | |
| 1526 elif force or m2[f] != a or (p2 == pa and mw[f] == m1[f]): | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1527 self.ui.debug(_(" remote %s is newer, get\n") % f) |
| 254 | 1528 get[f] = m2[f] |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1529 s = 1 |
| 576 | 1530 elif f in umap: |
| 1531 # this unknown file is the same as the checkout | |
| 1532 get[f] = m2[f] | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1533 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1534 if not s and mfw[f] != mf2[f]: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1535 if force: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1536 self.ui.debug(_(" updating permissions for %s\n") % f) |
| 441 | 1537 util.set_exec(self.wjoin(f), mf2[f]) |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1538 else: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1539 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1540 mode = ((a^b) | (a^c)) ^ a |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1541 if mode != b: |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1542 self.ui.debug(_(" updating permissions for %s\n") |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1543 % f) |
| 441 | 1544 util.set_exec(self.wjoin(f), mode) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1545 del m2[f] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1546 elif f in ma: |
| 616 | 1547 if n != ma[f]: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1548 r = _("d") |
| 616 | 1549 if not force and (linear_path or allow): |
|
415
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1550 r = self.ui.prompt( |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1551 (_(" local changed %s which remote deleted\n") % f) + |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1552 _("(k)eep or (d)elete?"), _("[kd]"), _("k")) |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1553 if r == _("d"): |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1554 remove.append(f) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1555 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1556 self.ui.debug(_("other deleted %s\n") % f) |
| 254 | 1557 remove.append(f) # other deleted it |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1558 else: |
|
1236
67a28636ea64
Fix bug with co -C across branches, update tests
mpm@selenic.com
parents:
1234
diff
changeset
|
1559 # file is created on branch or in working directory |
|
67a28636ea64
Fix bug with co -C across branches, update tests
mpm@selenic.com
parents:
1234
diff
changeset
|
1560 if force and f not in umap: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1561 self.ui.debug(_("remote deleted %s, clobbering\n") % f) |
|
1236
67a28636ea64
Fix bug with co -C across branches, update tests
mpm@selenic.com
parents:
1234
diff
changeset
|
1562 remove.append(f) |
|
67a28636ea64
Fix bug with co -C across branches, update tests
mpm@selenic.com
parents:
1234
diff
changeset
|
1563 elif n == m1.get(f, nullid): # same as parent |
|
1234
9ee8428d84a1
Revert unrelated changes in previous commit
mpm@selenic.com
parents:
1233
diff
changeset
|
1564 if p2 == pa: # going backwards? |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1565 self.ui.debug(_("remote deleted %s\n") % f) |
|
1234
9ee8428d84a1
Revert unrelated changes in previous commit
mpm@selenic.com
parents:
1233
diff
changeset
|
1566 remove.append(f) |
|
9ee8428d84a1
Revert unrelated changes in previous commit
mpm@selenic.com
parents:
1233
diff
changeset
|
1567 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1568 self.ui.debug(_("local modified %s, keeping\n") % f) |
| 254 | 1569 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1570 self.ui.debug(_("working dir created %s, keeping\n") % f) |
| 46 | 1571 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1572 for f, n in m2.iteritems(): |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1573 if choose and not choose(f): |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1574 continue |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1575 if f[0] == "/": |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1576 continue |
| 616 | 1577 if f in ma and n != ma[f]: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1578 r = _("k") |
| 616 | 1579 if not force and (linear_path or allow): |
|
415
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1580 r = self.ui.prompt( |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1581 (_("remote changed %s which local deleted\n") % f) + |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1582 _("(k)eep or (d)elete?"), _("[kd]"), _("k")) |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1583 if r == _("k"): |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1584 get[f] = n |
| 616 | 1585 elif f not in ma: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1586 self.ui.debug(_("remote created %s\n") % f) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1587 get[f] = n |
| 616 | 1588 else: |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1589 if force or p2 == pa: # going backwards? |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1590 self.ui.debug(_("local deleted %s, recreating\n") % f) |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1591 get[f] = n |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1592 else: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1593 self.ui.debug(_("local deleted %s\n") % f) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1594 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1595 del mw, m1, m2, ma |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1596 |
| 275 | 1597 if force: |
| 1598 for f in merge: | |
| 1599 get[f] = merge[f][1] | |
| 1600 merge = {} | |
| 1601 | |
| 690 | 1602 if linear_path or force: |
| 254 | 1603 # we don't need to do any magic, just jump to the new rev |
| 993 | 1604 branch_merge = False |
| 254 | 1605 p1, p2 = p2, nullid |
| 1606 else: | |
| 275 | 1607 if not allow: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1608 self.ui.status(_("this update spans a branch" |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1609 " affecting the following files:\n")) |
| 305 | 1610 fl = merge.keys() + get.keys() |
| 1611 fl.sort() | |
| 1612 for f in fl: | |
| 1613 cf = "" | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1614 if f in merge: |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1615 cf = _(" (resolve)") |
| 305 | 1616 self.ui.status(" %s%s\n" % (f, cf)) |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1617 self.ui.warn(_("aborting update spanning branches!\n")) |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1618 self.ui.status(_("(use update -m to merge across branches" |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1619 " or -C to lose changes)\n")) |
| 275 | 1620 return 1 |
| 993 | 1621 branch_merge = True |
| 254 | 1622 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1623 # get the files we don't need to change |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1624 files = get.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1625 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1626 for f in files: |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1627 if f[0] == "/": |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1628 continue |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1629 self.ui.note(_("getting %s\n") % f) |
| 276 | 1630 t = self.file(f).read(get[f]) |
|
1477
d3566eda2bcb
util.opener already create the base directory if it doesn't exist
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1473
diff
changeset
|
1631 self.wwrite(f, t) |
| 441 | 1632 util.set_exec(self.wjoin(f), mf2[f]) |
| 588 | 1633 if moddirstate: |
| 993 | 1634 if branch_merge: |
| 1635 self.dirstate.update([f], 'n', st_mtime=-1) | |
|
992
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
1636 else: |
|
f859e9cba1b9
Fix up some bugs introduced by recent merge changes
mpm@selenic.com
parents:
991
diff
changeset
|
1637 self.dirstate.update([f], 'n') |
| 46 | 1638 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1639 # merge the tricky bits |
|
1922
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1640 failedmerge = [] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1641 files = merge.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1642 files.sort() |
|
1883
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1643 xp1 = hex(p1) |
|
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1644 xp2 = hex(p2) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1645 for f in files: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1646 self.ui.status(_("merging %s\n") % f) |
| 993 | 1647 my, other, flag = merge[f] |
|
1883
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1648 ret = self.merge3(f, my, other, xp1, xp2) |
|
1663
d529cdc0a3ee
return a non-zero exit code when a merge failed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1645
diff
changeset
|
1649 if ret: |
|
d529cdc0a3ee
return a non-zero exit code when a merge failed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1645
diff
changeset
|
1650 err = True |
|
1922
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1651 failedmerge.append(f) |
| 441 | 1652 util.set_exec(self.wjoin(f), flag) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1653 if moddirstate: |
| 993 | 1654 if branch_merge: |
| 1655 # We've done a branch merge, mark this file as merged | |
| 1656 # so that we properly record the merger later | |
| 1657 self.dirstate.update([f], 'm') | |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1658 else: |
| 993 | 1659 # We've update-merged a locally modified file, so |
| 1660 # we set the dirstate to emulate a normal checkout | |
| 1661 # of that file some time in the past. Thus our | |
| 1662 # merge will appear as a normal local file | |
| 1663 # modification. | |
| 1664 f_len = len(self.file(f).read(other)) | |
| 1665 self.dirstate.update([f], 'n', st_size=f_len, st_mtime=-1) | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1666 |
| 681 | 1667 remove.sort() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1668 for f in remove: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1669 self.ui.note(_("removing %s\n") % f) |
|
1835
bdfb524d728a
Validate paths before reading or writing files in repository or working dir.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1807
diff
changeset
|
1670 util.audit_path(f) |
| 690 | 1671 try: |
|
1415
c6e6ca96a033
refactor some unlink/remove code and make sure we prune empty dir
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
1672 util.unlink(self.wjoin(f)) |
| 690 | 1673 except OSError, inst: |
|
1398
3f76ac60130d
make update quieter when nothing is wrong
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1384
diff
changeset
|
1674 if inst.errno != errno.ENOENT: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1675 self.ui.warn(_("update failed to remove %s: %s!\n") % |
|
1398
3f76ac60130d
make update quieter when nothing is wrong
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1384
diff
changeset
|
1676 (f, inst.strerror)) |
| 588 | 1677 if moddirstate: |
| 993 | 1678 if branch_merge: |
| 1679 self.dirstate.update(remove, 'r') | |
| 1680 else: | |
| 588 | 1681 self.dirstate.forget(remove) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1682 |
|
1495
1e265c2bec94
Deal with merge abort more gracefully
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1683 if moddirstate: |
|
1e265c2bec94
Deal with merge abort more gracefully
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1684 self.dirstate.setparents(p1, p2) |
|
1922
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1685 |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1686 stat = ((len(get), _("updated")), |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1687 (len(merge) - len(failedmerge), _("merged")), |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1688 (len(remove), _("removed")), |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1689 (len(failedmerge), _("unresolved"))) |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1690 note = ", ".join([_("%d files %s") % s for s in stat]) |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1691 self.ui.note("%s\n" % note) |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1692 if moddirstate and branch_merge: |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1693 self.ui.note(_("(branch merge, don't forget to commit)\n")) |
|
6d50d6189269
ui: output the number of file updated/merged/removed/... on update
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1893
diff
changeset
|
1694 |
|
1663
d529cdc0a3ee
return a non-zero exit code when a merge failed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1645
diff
changeset
|
1695 return err |
|
1495
1e265c2bec94
Deal with merge abort more gracefully
Matt Mackall <mpm@selenic.com>
parents:
1493
diff
changeset
|
1696 |
|
1883
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1697 def merge3(self, fn, my, other, p1, p2): |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1698 """perform a 3-way merge in the working directory""" |
| 249 | 1699 |
| 96 | 1700 def temp(prefix, node): |
| 1701 pre = "%s~%s." % (os.path.basename(fn), prefix) | |
| 1702 (fd, name) = tempfile.mkstemp("", pre) | |
| 417 | 1703 f = os.fdopen(fd, "wb") |
|
1019
a9cca981c423
Create helper functions for I/O to files in the working directory
mpm@selenic.com
parents:
1013
diff
changeset
|
1704 self.wwrite(fn, fl.read(node), f) |
| 96 | 1705 f.close() |
| 1706 return name | |
| 1707 | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1708 fl = self.file(fn) |
| 96 | 1709 base = fl.ancestor(my, other) |
| 244 | 1710 a = self.wjoin(fn) |
| 346 | 1711 b = temp("base", base) |
| 1712 c = temp("other", other) | |
| 96 | 1713 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1714 self.ui.note(_("resolving %s\n") % fn) |
|
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1715 self.ui.debug(_("file %s: my %s other %s ancestor %s\n") % |
|
1349
c6295d2a361e
More info on file merge for update --debug
Matt Mackall <mpm@selenic.com>
parents:
1346
diff
changeset
|
1716 (fn, short(my), short(other), short(base))) |
| 96 | 1717 |
|
703
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1718 cmd = (os.environ.get("HGMERGE") or self.ui.config("ui", "merge") |
|
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1719 or "hgmerge") |
|
1885
c4d577262d00
run merge program in repo root.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1883
diff
changeset
|
1720 r = util.system('%s "%s" "%s" "%s"' % (cmd, a, b, c), cwd=self.root, |
|
c4d577262d00
run merge program in repo root.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1883
diff
changeset
|
1721 environ={'HG_FILE': fn, |
|
1883
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1722 'HG_MY_NODE': p1, |
|
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1723 'HG_OTHER_NODE': p2, |
|
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1724 'HG_FILE_MY_NODE': hex(my), |
|
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1725 'HG_FILE_OTHER_NODE': hex(other), |
|
b98160cfb2f3
give more info to hgmerge script.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1882
diff
changeset
|
1726 'HG_FILE_BASE_NODE': hex(base)}) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1727 if r: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1728 self.ui.warn(_("merging %s failed!\n") % fn) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1729 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1730 os.unlink(b) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1731 os.unlink(c) |
|
1663
d529cdc0a3ee
return a non-zero exit code when a merge failed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1645
diff
changeset
|
1732 return r |
| 96 | 1733 |
| 247 | 1734 def verify(self): |
| 1735 filelinkrevs = {} | |
| 1736 filenodes = {} | |
| 1737 changesets = revisions = files = 0 | |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1738 errors = [0] |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1739 neededmanifests = {} |
| 247 | 1740 |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1741 def err(msg): |
|
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1742 self.ui.warn(msg + "\n") |
|
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1743 errors[0] += 1 |
|
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1744 |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1745 def checksize(obj, name): |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1746 d = obj.checksize() |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1747 if d[0]: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1748 err(_("%s data length off by %d bytes") % (name, d[0])) |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1749 if d[1]: |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1750 err(_("%s index contains %d extra bytes") % (name, d[1])) |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1751 |
| 302 | 1752 seen = {} |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1753 self.ui.status(_("checking changesets\n")) |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1754 checksize(self.changelog, "changelog") |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1755 |
| 247 | 1756 for i in range(self.changelog.count()): |
| 1757 changesets += 1 | |
| 1758 n = self.changelog.node(i) | |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1759 l = self.changelog.linkrev(n) |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1760 if l != i: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1761 err(_("incorrect link (%d) for changeset revision %d") %(l, i)) |
| 302 | 1762 if n in seen: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1763 err(_("duplicate changeset at revision %d") % i) |
| 302 | 1764 seen[n] = 1 |
| 515 | 1765 |
| 247 | 1766 for p in self.changelog.parents(n): |
| 1767 if p not in self.changelog.nodemap: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1768 err(_("changeset %s has unknown parent %s") % |
| 247 | 1769 (short(n), short(p))) |
| 1770 try: | |
| 1771 changes = self.changelog.read(n) | |
|
1492
5f0522d31967
Allow interrupting all parts of verify
Matt Mackall <mpm@selenic.com>
parents:
1480
diff
changeset
|
1772 except KeyboardInterrupt: |
|
5f0522d31967
Allow interrupting all parts of verify
Matt Mackall <mpm@selenic.com>
parents:
1480
diff
changeset
|
1773 self.ui.warn(_("interrupted")) |
|
5f0522d31967
Allow interrupting all parts of verify
Matt Mackall <mpm@selenic.com>
parents:
1480
diff
changeset
|
1774 raise |
| 247 | 1775 except Exception, inst: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1776 err(_("unpacking changeset %s: %s") % (short(n), inst)) |
|
1853
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1777 continue |
| 247 | 1778 |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1779 neededmanifests[changes[0]] = n |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1780 |
| 247 | 1781 for f in changes[3]: |
| 1782 filelinkrevs.setdefault(f, []).append(i) | |
| 1783 | |
| 302 | 1784 seen = {} |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1785 self.ui.status(_("checking manifests\n")) |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1786 checksize(self.manifest, "manifest") |
|
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1787 |
| 247 | 1788 for i in range(self.manifest.count()): |
| 1789 n = self.manifest.node(i) | |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1790 l = self.manifest.linkrev(n) |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1791 |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1792 if l < 0 or l >= self.changelog.count(): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1793 err(_("bad manifest link (%d) at revision %d") % (l, i)) |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1794 |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1795 if n in neededmanifests: |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1796 del neededmanifests[n] |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1797 |
| 302 | 1798 if n in seen: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1799 err(_("duplicate manifest at revision %d") % i) |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1800 |
| 302 | 1801 seen[n] = 1 |
| 515 | 1802 |
| 247 | 1803 for p in self.manifest.parents(n): |
| 1804 if p not in self.manifest.nodemap: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1805 err(_("manifest %s has unknown parent %s") % |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1806 (short(n), short(p))) |
| 247 | 1807 |
| 1808 try: | |
| 1809 delta = mdiff.patchtext(self.manifest.delta(n)) | |
| 1810 except KeyboardInterrupt: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1811 self.ui.warn(_("interrupted")) |
|
1097
1f89ccbab6ce
localrepo: adjust some imports, remove sys dependency
mpm@selenic.com
parents:
1089
diff
changeset
|
1812 raise |
| 247 | 1813 except Exception, inst: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1814 err(_("unpacking manifest %s: %s") % (short(n), inst)) |
|
1853
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1815 continue |
| 247 | 1816 |
|
1853
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1817 try: |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1818 ff = [ l.split('\0') for l in delta.splitlines() ] |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1819 for f, fn in ff: |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1820 filenodes.setdefault(f, {})[bin(fn[:40])] = 1 |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1821 except (ValueError, TypeError), inst: |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1822 err(_("broken delta in manifest %s: %s") % (short(n), inst)) |
| 247 | 1823 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1824 self.ui.status(_("crosschecking files in changesets and manifests\n")) |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1825 |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1826 for m, c in neededmanifests.items(): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1827 err(_("Changeset %s refers to unknown manifest %s") % |
|
1384
d729850d52fa
hg verify: add some bin to hex conversions
Matt Mackall <mpm@selenic.com>
parents:
1383
diff
changeset
|
1828 (short(m), short(c))) |
|
1382
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1829 del neededmanifests |
|
b113e7db06e9
hg verify: more consistency checking between changesets and manifests
Matt Mackall <mpm@selenic.com>
parents:
1375
diff
changeset
|
1830 |
| 247 | 1831 for f in filenodes: |
| 1832 if f not in filelinkrevs: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1833 err(_("file %s in manifest but not in changesets") % f) |
| 247 | 1834 |
| 1835 for f in filelinkrevs: | |
| 1836 if f not in filenodes: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1837 err(_("file %s in changeset but not in manifest") % f) |
| 247 | 1838 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1839 self.ui.status(_("checking files\n")) |
| 247 | 1840 ff = filenodes.keys() |
| 1841 ff.sort() | |
| 1842 for f in ff: | |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1843 if f == "/dev/null": |
|
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1844 continue |
| 247 | 1845 files += 1 |
|
1853
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1846 if not f: |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1847 err(_("file without name in manifest %s") % short(n)) |
|
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1848 continue |
| 247 | 1849 fl = self.file(f) |
|
1667
daff3ef0de8d
verify: notice extra data in indices
Matt Mackall <mpm@selenic.com>
parents:
1663
diff
changeset
|
1850 checksize(fl, f) |
|
1493
1a216cb4ee64
verify: add check for mismatch of index and data length
Matt Mackall <mpm@selenic.com>
parents:
1492
diff
changeset
|
1851 |
|
1615
83238c1db6de
Cleanup of indentation, spacing, newlines, strings and line length
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1597
diff
changeset
|
1852 nodes = {nullid: 1} |
| 302 | 1853 seen = {} |
| 247 | 1854 for i in range(fl.count()): |
| 1855 revisions += 1 | |
| 1856 n = fl.node(i) | |
| 1857 | |
| 302 | 1858 if n in seen: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1859 err(_("%s: duplicate revision %d") % (f, i)) |
| 247 | 1860 if n not in filenodes[f]: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1861 err(_("%s: %d:%s not in manifests") % (f, i, short(n))) |
| 247 | 1862 else: |
| 1863 del filenodes[f][n] | |
| 1864 | |
| 1865 flr = fl.linkrev(n) | |
|
1853
5ac811b720de
Fix some problems when working on broken repositories:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1839
diff
changeset
|
1866 if flr not in filelinkrevs.get(f, []): |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1867 err(_("%s:%s points to unexpected changeset %d") |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1868 % (f, short(n), flr)) |
| 247 | 1869 else: |
| 1870 filelinkrevs[f].remove(flr) | |
| 1871 | |
| 1872 # verify contents | |
| 1873 try: | |
| 1874 t = fl.read(n) | |
|
1492
5f0522d31967
Allow interrupting all parts of verify
Matt Mackall <mpm@selenic.com>
parents:
1480
diff
changeset
|
1875 except KeyboardInterrupt: |
|
5f0522d31967
Allow interrupting all parts of verify
Matt Mackall <mpm@selenic.com>
parents:
1480
diff
changeset
|
1876 self.ui.warn(_("interrupted")) |
|
5f0522d31967
Allow interrupting all parts of verify
Matt Mackall <mpm@selenic.com>
parents:
1480
diff
changeset
|
1877 raise |
| 247 | 1878 except Exception, inst: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1879 err(_("unpacking file %s %s: %s") % (f, short(n), inst)) |
| 247 | 1880 |
| 1881 # verify parents | |
| 1882 (p1, p2) = fl.parents(n) | |
| 1883 if p1 not in nodes: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1884 err(_("file %s:%s unknown parent 1 %s") % |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1885 (f, short(n), short(p1))) |
| 247 | 1886 if p2 not in nodes: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1887 err(_("file %s:%s unknown parent 2 %s") % |
| 247 | 1888 (f, short(n), short(p1))) |
| 1889 nodes[n] = 1 | |
| 1890 | |
| 1891 # cross-check | |
| 1892 for node in filenodes[f]: | |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1893 err(_("node %s in manifests not in %s") % (hex(node), f)) |
| 247 | 1894 |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1895 self.ui.status(_("%d files, %d changesets, %d total revisions\n") % |
| 247 | 1896 (files, changesets, revisions)) |
| 1897 | |
|
1383
3d6d45faf8b2
hg verify: add an error reporting helper function
Matt Mackall <mpm@selenic.com>
parents:
1382
diff
changeset
|
1898 if errors[0]: |
|
1402
9d2c2e6b32b5
i18n part2: use '_' for all strings who are part of the user interface
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1400
diff
changeset
|
1899 self.ui.warn(_("%d integrity errors encountered!\n") % errors[0]) |
| 247 | 1900 return 1 |
|
1806
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1901 |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1902 # used to avoid circular references so destructors work |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1903 def aftertrans(base): |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1904 p = base |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1905 def a(): |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1906 util.rename(os.path.join(p, "journal"), os.path.join(p, "undo")) |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1907 util.rename(os.path.join(p, "journal.dirstate"), |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1908 os.path.join(p, "undo.dirstate")) |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1909 return a |
|
a2c69737e65e
Automatic nesting into running transactions in the same repository.
mason@suse.com
parents:
1802
diff
changeset
|
1910 |