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