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