Mercurial > public > mercurial-scm > hg
annotate mercurial/hg.py @ 635:85e2209d401c
Protocol switch from using generators to stream-like objects.
This allows the the pull side to precisely control how much data is
read so that another encapsulation layer is not needed.
An http client gets a response with a finite size. Because ssh clients
need to keep the stream open, we must not read more data than is sent
in a response. But due to the streaming nature of the changegroup
scheme, only the piece that's parsing the data knows how far it's
allowed to read.
This means the generator scheme isn't fine-grained enough. Instead we
need file-like objects with a read(x) method. This switches everything
for push/pull over to using file-like objects rather than generators.
| author | Matt Mackall <mpm@selenic.com> |
|---|---|
| date | Wed, 06 Jul 2005 22:20:12 -0800 |
| parents | da5378d39269 |
| children | ac0ec421e3a5 |
| rev | line source |
|---|---|
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1 # hg.py - repository classes for mercurial |
|
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 |
| 249 | 8 import sys, struct, os |
|
419
28511fc21073
[PATCH] file seperator handling for the other 'OS'
mpm@selenic.com
parents:
418
diff
changeset
|
9 import util |
| 262 | 10 from revlog import * |
| 11 from demandload import * | |
| 12 demandload(globals(), "re lock urllib urllib2 transaction time socket") | |
| 434 | 13 demandload(globals(), "tempfile httprangereader bdiff") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
14 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
15 class filelog(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
16 def __init__(self, opener, path): |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
17 revlog.__init__(self, opener, |
|
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
18 os.path.join("data", path + ".i"), |
|
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
19 os.path.join("data", path + ".d")) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
20 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
21 def read(self, node): |
| 360 | 22 t = self.revision(node) |
| 23 if t[:2] != '\1\n': | |
| 24 return t | |
| 25 s = t.find('\1\n', 2) | |
| 26 return t[s+2:] | |
| 27 | |
| 28 def readmeta(self, node): | |
| 29 t = self.revision(node) | |
| 30 if t[:2] != '\1\n': | |
| 31 return t | |
| 32 s = t.find('\1\n', 2) | |
| 33 mt = t[2:s] | |
| 34 for l in mt.splitlines(): | |
| 35 k, v = l.split(": ", 1) | |
| 36 m[k] = v | |
| 37 return m | |
| 38 | |
| 39 def add(self, text, meta, transaction, link, p1=None, p2=None): | |
| 40 if meta or text[:2] == '\1\n': | |
| 41 mt = "" | |
| 42 if meta: | |
| 43 mt = [ "%s: %s\n" % (k, v) for k,v in meta.items() ] | |
| 44 text = "\1\n" + "".join(mt) + "\1\n" + text | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
45 return self.addrevision(text, transaction, link, p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
46 |
| 79 | 47 def annotate(self, node): |
| 199 | 48 |
| 49 def decorate(text, rev): | |
| 436 | 50 return ([rev] * len(text.splitlines()), text) |
| 199 | 51 |
| 52 def pair(parent, child): | |
| 436 | 53 for a1, a2, b1, b2 in bdiff.blocks(parent[1], child[1]): |
| 471 | 54 child[0][b1:b2] = parent[0][a1:a2] |
| 55 return child | |
| 199 | 56 |
| 200 | 57 # find all ancestors |
|
216
201115f2859b
hg annotate: actually annotate the given version
mpm@selenic.com
parents:
210
diff
changeset
|
58 needed = {node:1} |
| 199 | 59 visit = [node] |
| 60 while visit: | |
| 61 n = visit.pop(0) | |
| 62 for p in self.parents(n): | |
| 63 if p not in needed: | |
| 64 needed[p] = 1 | |
| 65 visit.append(p) | |
| 200 | 66 else: |
| 67 # count how many times we'll use this | |
| 68 needed[p] += 1 | |
| 199 | 69 |
| 200 | 70 # sort by revision which is a topological order |
| 471 | 71 visit = [ (self.rev(n), n) for n in needed.keys() ] |
| 199 | 72 visit.sort() |
| 73 hist = {} | |
| 74 | |
| 471 | 75 for r,n in visit: |
| 199 | 76 curr = decorate(self.read(n), self.linkrev(n)) |
| 77 for p in self.parents(n): | |
| 78 if p != nullid: | |
| 79 curr = pair(hist[p], curr) | |
| 200 | 80 # trim the history of unneeded revs |
| 81 needed[p] -= 1 | |
| 82 if not needed[p]: | |
| 83 del hist[p] | |
| 199 | 84 hist[n] = curr |
| 85 | |
| 436 | 86 return zip(hist[n][0], hist[n][1].splitlines(1)) |
| 79 | 87 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
88 class manifest(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
89 def __init__(self, opener): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
90 self.mapcache = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
91 self.listcache = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
92 self.addlist = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
93 revlog.__init__(self, opener, "00manifest.i", "00manifest.d") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
94 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
95 def read(self, node): |
| 313 | 96 if node == nullid: return {} # don't upset local cache |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
97 if self.mapcache and self.mapcache[0] == node: |
| 561 | 98 return self.mapcache[1] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
99 text = self.revision(node) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
100 map = {} |
| 276 | 101 flag = {} |
|
25
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
102 self.listcache = (text, text.splitlines(1)) |
|
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
103 for l in self.listcache[1]: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
104 (f, n) = l.split('\0') |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
105 map[f] = bin(n[:40]) |
| 276 | 106 flag[f] = (n[40:-1] == "x") |
| 107 self.mapcache = (node, map, flag) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
108 return map |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
109 |
| 276 | 110 def readflags(self, node): |
| 313 | 111 if node == nullid: return {} # don't upset local cache |
|
358
9f4077d7ef6f
[PATCH] manifest.readflags performance buglet
mpm@selenic.com
parents:
350
diff
changeset
|
112 if not self.mapcache or self.mapcache[0] != node: |
| 276 | 113 self.read(node) |
| 114 return self.mapcache[2] | |
| 115 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
116 def diff(self, a, b): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
117 # this is sneaky, as we're not actually using a and b |
| 140 | 118 if self.listcache and self.addlist and self.listcache[0] == a: |
| 98 | 119 d = mdiff.diff(self.listcache[1], self.addlist, 1) |
| 120 if mdiff.patch(a, d) != b: | |
| 121 sys.stderr.write("*** sortdiff failed, falling back ***\n") | |
| 122 return mdiff.textdiff(a, b) | |
| 123 return d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
124 else: |
| 44 | 125 return mdiff.textdiff(a, b) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
126 |
| 276 | 127 def add(self, map, flags, transaction, link, p1=None, p2=None): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
128 files = map.keys() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
129 files.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
130 |
| 276 | 131 self.addlist = ["%s\000%s%s\n" % |
| 132 (f, hex(map[f]), flags[f] and "x" or '') | |
| 133 for f in files] | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
134 text = "".join(self.addlist) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
135 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
136 n = self.addrevision(text, transaction, link, p1, p2) |
| 302 | 137 self.mapcache = (n, map, flags) |
|
25
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
138 self.listcache = (text, self.addlist) |
| 140 | 139 self.addlist = None |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
140 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
141 return n |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
142 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
143 class changelog(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
144 def __init__(self, opener): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
145 revlog.__init__(self, opener, "00changelog.i", "00changelog.d") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
146 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
147 def extract(self, text): |
| 37 | 148 if not text: |
| 40 | 149 return (nullid, "", "0", [], "") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
150 last = text.index("\n\n") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
151 desc = text[last + 2:] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
152 l = text[:last].splitlines() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
153 manifest = bin(l[0]) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
154 user = l[1] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
155 date = l[2] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
156 files = l[3:] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
157 return (manifest, user, date, files, desc) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
158 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
159 def read(self, node): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
160 return self.extract(self.revision(node)) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
161 |
| 203 | 162 def add(self, manifest, list, desc, transaction, p1=None, p2=None, |
| 163 user=None, date=None): | |
| 164 date = date or "%d %d" % (time.time(), time.timezone) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
165 list.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
166 l = [hex(manifest), user, date] + list + ["", desc] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
167 text = "\n".join(l) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
168 return self.addrevision(text, transaction, self.count(), p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
169 |
| 220 | 170 class dirstate: |
| 244 | 171 def __init__(self, opener, ui, root): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
172 self.opener = opener |
| 244 | 173 self.root = root |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
174 self.dirty = 0 |
| 20 | 175 self.ui = ui |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
176 self.map = None |
| 227 | 177 self.pl = None |
| 363 | 178 self.copies = {} |
| 220 | 179 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
180 def __del__(self): |
| 220 | 181 if self.dirty: |
| 182 self.write() | |
| 183 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
184 def __getitem__(self, key): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
185 try: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
186 return self.map[key] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
187 except TypeError: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
188 self.read() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
189 return self[key] |
| 220 | 190 |
| 191 def __contains__(self, key): | |
| 192 if not self.map: self.read() | |
| 193 return key in self.map | |
| 194 | |
| 227 | 195 def parents(self): |
| 196 if not self.pl: | |
| 197 self.read() | |
| 198 return self.pl | |
| 199 | |
| 200 def setparents(self, p1, p2 = nullid): | |
| 201 self.dirty = 1 | |
| 202 self.pl = p1, p2 | |
| 203 | |
| 220 | 204 def state(self, key): |
| 205 try: | |
| 206 return self[key][0] | |
| 207 except KeyError: | |
| 208 return "?" | |
| 209 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
210 def read(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
211 if self.map is not None: return self.map |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
212 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
213 self.map = {} |
| 227 | 214 self.pl = [nullid, nullid] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
215 try: |
| 220 | 216 st = self.opener("dirstate").read() |
| 311 | 217 if not st: return |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
218 except: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
219 |
| 227 | 220 self.pl = [st[:20], st[20: 40]] |
| 221 | |
| 222 pos = 40 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
223 while pos < len(st): |
| 220 | 224 e = struct.unpack(">cllll", st[pos:pos+17]) |
| 225 l = e[4] | |
| 226 pos += 17 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
227 f = st[pos:pos + l] |
| 515 | 228 if '\0' in f: |
| 363 | 229 f, c = f.split('\0') |
| 230 self.copies[f] = c | |
| 220 | 231 self.map[f] = e[:4] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
232 pos += l |
| 363 | 233 |
| 234 def copy(self, source, dest): | |
| 235 self.read() | |
| 236 self.dirty = 1 | |
| 237 self.copies[dest] = source | |
| 238 | |
| 239 def copied(self, file): | |
| 240 return self.copies.get(file, None) | |
| 515 | 241 |
| 220 | 242 def update(self, files, state): |
| 243 ''' current states: | |
| 244 n normal | |
| 231 | 245 m needs merging |
| 220 | 246 r marked for removal |
| 247 a marked for addition''' | |
| 248 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
249 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
250 self.read() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
251 self.dirty = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
252 for f in files: |
| 220 | 253 if state == "r": |
| 254 self.map[f] = ('r', 0, 0, 0) | |
| 255 else: | |
| 253 | 256 s = os.stat(os.path.join(self.root, f)) |
| 257 self.map[f] = (state, s.st_mode, s.st_size, s.st_mtime) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
258 |
| 220 | 259 def forget(self, files): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
260 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
261 self.read() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
262 self.dirty = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
263 for f in files: |
| 20 | 264 try: |
| 265 del self.map[f] | |
| 266 except KeyError: | |
| 220 | 267 self.ui.warn("not in dirstate: %s!\n" % f) |
| 20 | 268 pass |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
269 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
270 def clear(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
271 self.map = {} |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
272 self.dirty = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
273 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
274 def write(self): |
| 220 | 275 st = self.opener("dirstate", "w") |
| 227 | 276 st.write("".join(self.pl)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
277 for f, e in self.map.items(): |
| 363 | 278 c = self.copied(f) |
| 279 if c: | |
| 280 f = f + "\0" + c | |
| 220 | 281 e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
282 st.write(e + f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
283 self.dirty = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
284 |
| 536 | 285 def changes(self, files, ignore): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
286 self.read() |
| 536 | 287 dc = self.map.copy() |
| 288 lookup, changed, added, unknown = [], [], [], [] | |
| 289 | |
| 290 # compare all files by default | |
| 291 if not files: files = [self.root] | |
| 292 | |
| 293 # recursive generator of all files listed | |
| 294 def walk(files): | |
| 556 | 295 for f in util.unique(files): |
| 537 | 296 f = os.path.join(self.root, f) |
| 536 | 297 if os.path.isdir(f): |
| 298 for dir, subdirs, fl in os.walk(f): | |
| 299 d = dir[len(self.root) + 1:] | |
| 300 if ".hg" in subdirs: subdirs.remove(".hg") | |
| 301 for fn in fl: | |
| 302 fn = util.pconvert(os.path.join(d, fn)) | |
| 303 yield fn | |
| 304 else: | |
| 305 yield f[len(self.root) + 1:] | |
| 306 | |
| 556 | 307 for fn in util.unique(walk(files)): |
| 536 | 308 try: s = os.stat(os.path.join(self.root, fn)) |
| 309 except: continue | |
| 310 | |
| 311 if fn in dc: | |
| 312 c = dc[fn] | |
| 313 del dc[fn] | |
| 314 | |
| 315 if c[0] == 'm': | |
| 316 changed.append(fn) | |
| 317 elif c[0] == 'a': | |
| 318 added.append(fn) | |
| 319 elif c[0] == 'r': | |
| 320 unknown.append(fn) | |
| 321 elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100: | |
| 322 changed.append(fn) | |
| 323 elif c[1] != s.st_mode or c[3] != s.st_mtime: | |
| 324 lookup.append(fn) | |
| 325 else: | |
| 326 if not ignore(fn): unknown.append(fn) | |
| 327 | |
| 328 return (lookup, changed, added, dc.keys(), unknown) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
329 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
330 # used to avoid circular references so destructors work |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
331 def opener(base): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
332 p = base |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
333 def o(path, mode="r"): |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
334 if p[:7] == "http://": |
|
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
335 f = os.path.join(p, urllib.quote(path)) |
| 372 | 336 return httprangereader.httprangereader(f) |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
337 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
338 f = os.path.join(p, path) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
339 |
| 292 | 340 mode += "b" # for that other OS |
| 341 | |
| 342 if mode[0] != "r": | |
|
110
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
343 try: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
344 s = os.stat(f) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
345 except OSError: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
346 d = os.path.dirname(f) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
347 if not os.path.isdir(d): |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
348 os.makedirs(d) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
349 else: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
350 if s.st_nlink > 1: |
| 417 | 351 file(f + ".tmp", "wb").write(file(f, "rb").read()) |
| 421 | 352 util.rename(f+".tmp", f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
353 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
354 return file(f, mode) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
355 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
356 return o |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
357 |
| 499 | 358 class RepoError(Exception): pass |
| 359 | |
| 60 | 360 class localrepository: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
361 def __init__(self, ui, path=None, create=0): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
362 self.remote = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
363 if path and path[:7] == "http://": |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
364 self.remote = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
365 self.path = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
366 else: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
367 if not path: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
368 p = os.getcwd() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
369 while not os.path.isdir(os.path.join(p, ".hg")): |
|
420
dbe86d465e09
[PATCH] Repo locator fix for the other `OS'
mpm@selenic.com
parents:
419
diff
changeset
|
370 oldp = p |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
371 p = os.path.dirname(p) |
| 499 | 372 if p == oldp: raise RepoError("no repo found") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
373 path = p |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
374 self.path = os.path.join(path, ".hg") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
375 |
| 405 | 376 if not create and not os.path.isdir(self.path): |
| 499 | 377 raise RepoError("repository %s not found" % self.path) |
| 405 | 378 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
379 self.root = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
380 self.ui = ui |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
381 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
382 if create: |
| 515 | 383 os.mkdir(self.path) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
384 os.mkdir(self.join("data")) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
385 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
386 self.opener = opener(self.path) |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
387 self.wopener = opener(self.root) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
388 self.manifest = manifest(self.opener) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
389 self.changelog = changelog(self.opener) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
390 self.ignorelist = None |
| 343 | 391 self.tagscache = None |
| 392 self.nodetagscache = None | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
393 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
394 if not self.remote: |
| 244 | 395 self.dirstate = dirstate(self.opener, ui, self.root) |
| 337 | 396 try: |
| 397 self.ui.readconfig(self.opener("hgrc")) | |
| 398 except IOError: pass | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
399 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
400 def ignore(self, f): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
401 if self.ignorelist is None: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
402 self.ignorelist = [] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
403 try: |
| 417 | 404 l = file(self.wjoin(".hgignore")) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
405 for pat in l: |
| 9 | 406 if pat != "\n": |
|
419
28511fc21073
[PATCH] file seperator handling for the other 'OS'
mpm@selenic.com
parents:
418
diff
changeset
|
407 self.ignorelist.append(re.compile(util.pconvert(pat[:-1]))) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
408 except IOError: pass |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
409 for pat in self.ignorelist: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
410 if pat.search(f): return True |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
411 return False |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
412 |
| 487 | 413 def hook(self, name, **args): |
| 414 s = self.ui.config("hooks", name) | |
| 415 if s: | |
| 416 self.ui.note("running hook %s: %s\n" % (name, s)) | |
| 417 old = {} | |
| 418 for k, v in args.items(): | |
| 419 k = k.upper() | |
| 420 old[k] = os.environ.get(k, None) | |
| 421 os.environ[k] = v | |
| 422 | |
| 423 r = os.system(s) | |
| 424 | |
| 425 for k, v in old.items(): | |
| 426 if v != None: | |
| 427 os.environ[k] = v | |
| 428 else: | |
| 429 del os.environ[k] | |
| 430 | |
| 431 if r: | |
| 432 self.ui.warn("abort: %s hook failed with status %d!\n" % | |
| 433 (name, r)) | |
| 434 return False | |
| 435 return True | |
| 436 | |
| 343 | 437 def tags(self): |
| 438 '''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
|
439 if not self.tagscache: |
| 343 | 440 self.tagscache = {} |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
441 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
|
442 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
443 bin_n = bin(n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
444 except TypeError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
445 bin_n = '' |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
446 self.tagscache[k.strip()] = bin_n |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
447 |
| 67 | 448 try: |
| 254 | 449 # read each head of the tags file, ending with the tip |
| 450 # and add each tag found to the map, with "newer" ones | |
| 451 # taking precedence | |
| 67 | 452 fl = self.file(".hgtags") |
| 254 | 453 h = fl.heads() |
| 454 h.reverse() | |
| 455 for r in h: | |
| 456 for l in fl.revision(r).splitlines(): | |
| 457 if l: | |
|
385
e9e1efd5291c
Fixed problems with extra spaces around tags in .hgtags
Thomas Arendsen Hein <thomas@intevation.de>
parents:
383
diff
changeset
|
458 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
|
459 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
|
460 except KeyError: |
|
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
461 pass |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
462 |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
463 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
464 f = self.opener("localtags") |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
465 for l in f: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
466 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
|
467 addtag(self, k, n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
468 except IOError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
469 pass |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
470 |
| 343 | 471 self.tagscache['tip'] = self.changelog.tip() |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
472 |
| 343 | 473 return self.tagscache |
| 474 | |
| 475 def tagslist(self): | |
| 476 '''return a list of tags ordered by revision''' | |
| 477 l = [] | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
478 for t, n in self.tags().items(): |
| 343 | 479 try: |
| 480 r = self.changelog.rev(n) | |
| 481 except: | |
| 482 r = -2 # sort to the beginning of the list if unknown | |
| 483 l.append((r,t,n)) | |
| 484 l.sort() | |
| 485 return [(t,n) for r,t,n in l] | |
| 486 | |
| 487 def nodetags(self, node): | |
| 488 '''return the tags associated with a node''' | |
| 489 if not self.nodetagscache: | |
| 490 self.nodetagscache = {} | |
| 491 for t,n in self.tags().items(): | |
| 492 self.nodetagscache.setdefault(n,[]).append(t) | |
| 493 return self.nodetagscache.get(node, []) | |
| 494 | |
| 495 def lookup(self, key): | |
| 67 | 496 try: |
| 343 | 497 return self.tags()[key] |
| 67 | 498 except KeyError: |
| 499 return self.changelog.lookup(key) | |
| 500 | |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
501 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
502 if self.remote: return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
503 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
|
504 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
505 def join(self, f): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
506 return os.path.join(self.path, f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
507 |
| 244 | 508 def wjoin(self, f): |
| 509 return os.path.join(self.root, f) | |
| 510 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
511 def file(self, f): |
| 192 | 512 if f[0] == '/': f = f[1:] |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
513 return filelog(self.opener, f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
514 |
| 627 | 515 def getcwd(self): |
| 516 cwd = os.getcwd() | |
| 517 if cwd == self.root: return '' | |
| 518 return cwd[len(self.root) + 1:] | |
| 519 | |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
520 def wfile(self, f, mode='r'): |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
521 return self.wopener(f, mode) |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
522 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
523 def transaction(self): |
| 251 | 524 # save dirstate for undo |
| 263 | 525 try: |
| 526 ds = self.opener("dirstate").read() | |
| 527 except IOError: | |
| 528 ds = "" | |
| 251 | 529 self.opener("undo.dirstate", "w").write(ds) |
| 515 | 530 |
| 582 | 531 return transaction.transaction(self.ui.warn, |
| 532 self.opener, self.join("journal"), | |
| 262 | 533 self.join("undo")) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
534 |
| 210 | 535 def recover(self): |
| 225 | 536 lock = self.lock() |
| 557 | 537 if os.path.exists(self.join("journal")): |
| 501 | 538 self.ui.status("rolling back interrupted transaction\n") |
| 557 | 539 return transaction.rollback(self.opener, self.join("journal")) |
| 210 | 540 else: |
| 541 self.ui.warn("no interrupted transaction available\n") | |
| 542 | |
| 543 def undo(self): | |
| 225 | 544 lock = self.lock() |
| 210 | 545 if os.path.exists(self.join("undo")): |
| 501 | 546 self.ui.status("rolling back last transaction\n") |
| 262 | 547 transaction.rollback(self.opener, self.join("undo")) |
| 251 | 548 self.dirstate = None |
| 421 | 549 util.rename(self.join("undo.dirstate"), self.join("dirstate")) |
| 251 | 550 self.dirstate = dirstate(self.opener, self.ui, self.root) |
| 163 | 551 else: |
| 210 | 552 self.ui.warn("no undo information available\n") |
| 162 | 553 |
| 161 | 554 def lock(self, wait = 1): |
| 555 try: | |
| 556 return lock.lock(self.join("lock"), 0) | |
| 557 except lock.LockHeld, inst: | |
| 558 if wait: | |
| 559 self.ui.warn("waiting for lock held by %s\n" % inst.args[0]) | |
| 560 return lock.lock(self.join("lock"), wait) | |
| 561 raise inst | |
| 562 | |
| 203 | 563 def rawcommit(self, files, text, user, date, p1=None, p2=None): |
| 442 | 564 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
|
565 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
|
566 p2 = p2 or self.dirstate.parents()[1] or nullid |
| 302 | 567 c1 = self.changelog.read(p1) |
| 568 c2 = self.changelog.read(p2) | |
| 569 m1 = self.manifest.read(c1[0]) | |
| 570 mf1 = self.manifest.readflags(c1[0]) | |
| 571 m2 = self.manifest.read(c2[0]) | |
| 572 | |
| 442 | 573 if orig_parent == p1: |
| 574 update_dirstate = 1 | |
| 575 else: | |
| 576 update_dirstate = 0 | |
| 577 | |
| 203 | 578 tr = self.transaction() |
| 302 | 579 mm = m1.copy() |
| 580 mfm = mf1.copy() | |
| 203 | 581 linkrev = self.changelog.count() |
| 582 for f in files: | |
| 583 try: | |
| 302 | 584 t = self.wfile(f).read() |
| 441 | 585 tm = util.is_exec(self.wjoin(f), mfm.get(f, False)) |
| 302 | 586 r = self.file(f) |
| 587 mfm[f] = tm | |
| 360 | 588 mm[f] = r.add(t, {}, tr, linkrev, |
| 302 | 589 m1.get(f, nullid), m2.get(f, nullid)) |
| 442 | 590 if update_dirstate: |
| 591 self.dirstate.update([f], "n") | |
| 203 | 592 except IOError: |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
593 try: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
594 del mm[f] |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
595 del mfm[f] |
| 442 | 596 if update_dirstate: |
| 597 self.dirstate.forget([f]) | |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
598 except: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
599 # deleted from p2? |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
600 pass |
| 203 | 601 |
| 302 | 602 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
|
603 user = user or self.ui.username() |
| 302 | 604 n = self.changelog.add(mnode, files, text, tr, p1, p2, user, date) |
| 203 | 605 tr.close() |
| 442 | 606 if update_dirstate: |
| 607 self.dirstate.setparents(n, nullid) | |
| 203 | 608 |
| 317 | 609 def commit(self, files = None, text = "", user = None, date = None): |
| 220 | 610 commit = [] |
| 611 remove = [] | |
| 612 if files: | |
| 613 for f in files: | |
| 614 s = self.dirstate.state(f) | |
| 244 | 615 if s in 'nmai': |
| 220 | 616 commit.append(f) |
| 617 elif s == 'r': | |
| 618 remove.append(f) | |
| 619 else: | |
| 244 | 620 self.ui.warn("%s not tracked!\n" % f) |
| 220 | 621 else: |
| 536 | 622 (c, a, d, u) = self.changes(None, None) |
| 220 | 623 commit = c + a |
| 624 remove = d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
625 |
| 220 | 626 if not commit and not remove: |
| 151 | 627 self.ui.status("nothing changed\n") |
| 628 return | |
| 629 | |
| 487 | 630 if not self.hook("precommit"): |
| 631 return 1 | |
| 632 | |
| 229 | 633 p1, p2 = self.dirstate.parents() |
| 634 c1 = self.changelog.read(p1) | |
| 635 c2 = self.changelog.read(p2) | |
| 636 m1 = self.manifest.read(c1[0]) | |
| 276 | 637 mf1 = self.manifest.readflags(c1[0]) |
| 229 | 638 m2 = self.manifest.read(c2[0]) |
| 225 | 639 lock = self.lock() |
| 151 | 640 tr = self.transaction() |
| 641 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
642 # check in files |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
643 new = {} |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
644 linkrev = self.changelog.count() |
| 220 | 645 commit.sort() |
| 646 for f in commit: | |
| 83 | 647 self.ui.note(f + "\n") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
648 try: |
| 441 | 649 mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False)) |
| 418 | 650 t = self.wfile(f).read() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
651 except IOError: |
| 220 | 652 self.warn("trouble committing %s!\n" % f) |
| 653 raise | |
| 654 | |
| 363 | 655 meta = {} |
| 656 cp = self.dirstate.copied(f) | |
| 657 if cp: | |
| 658 meta["copy"] = cp | |
| 659 meta["copyrev"] = hex(m1.get(cp, m2.get(cp, nullid))) | |
| 575 | 660 self.ui.debug(" %s: copy %s:%s\n" % (f, cp, meta["copyrev"])) |
| 363 | 661 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
662 r = self.file(f) |
| 229 | 663 fp1 = m1.get(f, nullid) |
| 664 fp2 = m2.get(f, nullid) | |
| 363 | 665 new[f] = r.add(t, meta, tr, linkrev, fp1, fp2) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
666 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
667 # update manifest |
| 229 | 668 m1.update(new) |
|
416
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
669 for f in remove: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
670 if f in m1: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
671 del m1[f] |
| 276 | 672 mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0]) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
673 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
674 # add changeset |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
675 new = new.keys() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
676 new.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
677 |
| 288 | 678 if not text: |
| 679 edittext = "\n" + "HG: manifest hash %s\n" % hex(mn) | |
| 680 edittext += "".join(["HG: changed %s\n" % f for f in new]) | |
| 681 edittext += "".join(["HG: removed %s\n" % f for f in remove]) | |
| 682 edittext = self.ui.edit(edittext) | |
| 683 if not edittext.rstrip(): | |
| 684 return 1 | |
| 685 text = edittext | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
686 |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
687 user = user or self.ui.username() |
| 317 | 688 n = self.changelog.add(mn, new, text, tr, p1, p2, user, date) |
| 487 | 689 |
| 690 if not self.hook("commit", node=hex(n)): | |
| 691 return 1 | |
| 692 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
693 tr.close() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
694 |
| 229 | 695 self.dirstate.setparents(n) |
| 220 | 696 self.dirstate.update(new, "n") |
| 697 self.dirstate.forget(remove) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
698 |
| 537 | 699 def changes(self, node1, node2, files=None): |
| 566 | 700 mf2, u = None, [] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
701 |
| 536 | 702 def fcmp(fn, mf): |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
703 t1 = self.wfile(fn).read() |
| 29 | 704 t2 = self.file(fn).revision(mf[fn]) |
| 705 return cmp(t1, t2) | |
| 706 | |
| 536 | 707 # are we comparing the working directory? |
| 561 | 708 if not node2: |
| 536 | 709 l, c, a, d, u = self.dirstate.changes(files, self.ignore) |
| 710 | |
| 711 # are we comparing working dir against its parent? | |
| 561 | 712 if not node1: |
| 536 | 713 if l: |
| 714 # do a full compare of any files that might have changed | |
| 715 change = self.changelog.read(self.dirstate.parents()[0]) | |
| 561 | 716 mf2 = self.manifest.read(change[0]) |
| 548 | 717 for f in l: |
| 561 | 718 if fcmp(f, mf2): |
| 536 | 719 c.append(f) |
| 561 | 720 |
| 721 for l in c, a, d, u: | |
| 722 l.sort() | |
| 723 | |
| 536 | 724 return (c, a, d, u) |
| 515 | 725 |
| 536 | 726 # are we comparing working dir against non-tip? |
| 727 # generate a pseudo-manifest for the working dir | |
| 561 | 728 if not node2: |
| 729 if not mf2: | |
| 536 | 730 change = self.changelog.read(self.dirstate.parents()[0]) |
| 561 | 731 mf2 = self.manifest.read(change[0]).copy() |
| 536 | 732 for f in a + c + l: |
| 561 | 733 mf2[f] = "" |
| 536 | 734 for f in d: |
| 561 | 735 if f in mf2: del mf2[f] |
| 536 | 736 else: |
| 561 | 737 change = self.changelog.read(node2) |
| 738 mf2 = self.manifest.read(change[0]) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
739 |
| 566 | 740 # flush lists from dirstate before comparing manifests |
| 741 c, a = [], [] | |
| 742 | |
| 561 | 743 change = self.changelog.read(node1) |
| 744 mf1 = self.manifest.read(change[0]).copy() | |
| 32 | 745 |
| 746 for fn in mf2: | |
| 747 if mf1.has_key(fn): | |
| 748 if mf1[fn] != mf2[fn]: | |
| 561 | 749 if mf2[fn] != "" or fcmp(fn, mf1): |
| 536 | 750 c.append(fn) |
| 32 | 751 del mf1[fn] |
| 752 else: | |
| 536 | 753 a.append(fn) |
| 515 | 754 |
| 536 | 755 d = mf1.keys() |
| 561 | 756 |
| 757 for l in c, a, d, u: | |
| 758 l.sort() | |
| 515 | 759 |
| 536 | 760 return (c, a, d, u) |
| 32 | 761 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
762 def add(self, list): |
| 220 | 763 for f in list: |
| 244 | 764 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
|
765 if not os.path.exists(p): |
|
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
766 self.ui.warn("%s does not exist!\n" % f) |
|
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
767 elif not os.path.isfile(p): |
|
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
768 self.ui.warn("%s not added: mercurial only supports files currently\n" % f) |
| 220 | 769 elif self.dirstate.state(f) == 'n': |
| 770 self.ui.warn("%s already tracked!\n" % f) | |
| 771 else: | |
| 772 self.dirstate.update([f], "a") | |
| 773 | |
| 774 def forget(self, list): | |
| 775 for f in list: | |
| 776 if self.dirstate.state(f) not in 'ai': | |
| 777 self.ui.warn("%s not added!\n" % f) | |
| 778 else: | |
| 779 self.dirstate.forget([f]) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
780 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
781 def remove(self, list): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
782 for f in list: |
| 244 | 783 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
|
784 if os.path.exists(p): |
| 220 | 785 self.ui.warn("%s still exists!\n" % f) |
| 402 | 786 elif self.dirstate.state(f) == 'a': |
| 787 self.ui.warn("%s never committed!\n" % f) | |
| 788 self.dirstate.forget(f) | |
| 220 | 789 elif f not in self.dirstate: |
| 790 self.ui.warn("%s not tracked!\n" % f) | |
| 791 else: | |
| 792 self.dirstate.update([f], "r") | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
793 |
| 363 | 794 def copy(self, source, dest): |
| 795 p = self.wjoin(dest) | |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
796 if not os.path.exists(dest): |
| 363 | 797 self.ui.warn("%s does not exist!\n" % dest) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
798 elif not os.path.isfile(dest): |
|
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
799 self.ui.warn("copy failed: %s is not a file\n" % dest) |
| 363 | 800 else: |
| 801 if self.dirstate.state(dest) == '?': | |
| 802 self.dirstate.update([dest], "a") | |
| 803 self.dirstate.copy(source, dest) | |
| 804 | |
| 222 | 805 def heads(self): |
| 806 return self.changelog.heads() | |
| 807 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
808 def branches(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
809 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
|
810 b = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
811 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
812 t = n |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
813 while n: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
814 p = self.changelog.parents(n) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
815 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
|
816 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
|
817 break |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
818 n = p[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
819 return b |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
820 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
821 def between(self, pairs): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
822 r = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
823 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
824 for top, bottom in pairs: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
825 n, l, i = top, [], 0 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
826 f = 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
827 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
828 while n != bottom: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
829 p = self.changelog.parents(n)[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
830 if i == f: |
| 575 | 831 l.append(n) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
832 f = f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
833 n = p |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
834 i += 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
835 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
836 r.append(l) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
837 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
838 return r |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
839 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
840 def newer(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
841 m = {} |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
842 nl = [] |
| 94 | 843 pm = {} |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
844 cl = self.changelog |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
845 t = l = cl.count() |
| 94 | 846 |
| 847 # find the lowest numbered node | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
848 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
849 l = min(l, cl.rev(n)) |
| 94 | 850 m[n] = 1 |
| 46 | 851 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
852 for i in xrange(l, t): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
853 n = cl.node(i) |
| 94 | 854 if n in m: # explicitly listed |
| 855 pm[n] = 1 | |
| 856 nl.append(n) | |
| 857 continue | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
858 for p in cl.parents(n): |
| 94 | 859 if p in pm: # parent listed |
| 860 pm[n] = 1 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
861 nl.append(n) |
| 94 | 862 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
863 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
864 return nl |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
865 |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
866 def findincoming(self, remote, base={}): |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
867 m = self.changelog.nodemap |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
868 search = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
869 fetch = [] |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
870 seen = {} |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
871 seenbranch = {} |
| 192 | 872 |
|
190
3dd5ce2fddb6
merge: short-circuit search for merge into empty repo
mpm@selenic.com
parents:
187
diff
changeset
|
873 # if we have an empty repo, fetch everything |
|
3dd5ce2fddb6
merge: short-circuit search for merge into empty repo
mpm@selenic.com
parents:
187
diff
changeset
|
874 if self.changelog.tip() == nullid: |
| 222 | 875 self.ui.status("requesting all changes\n") |
| 516 | 876 return [nullid] |
|
190
3dd5ce2fddb6
merge: short-circuit search for merge into empty repo
mpm@selenic.com
parents:
187
diff
changeset
|
877 |
|
3dd5ce2fddb6
merge: short-circuit search for merge into empty repo
mpm@selenic.com
parents:
187
diff
changeset
|
878 # otherwise, 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
|
879 # and start by examining the heads |
| 222 | 880 self.ui.status("searching for changes\n") |
| 881 heads = remote.heads() | |
| 882 unknown = [] | |
| 883 for h in heads: | |
| 884 if h not in m: | |
| 885 unknown.append(h) | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
886 else: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
887 base[h] = 1 |
| 46 | 888 |
| 222 | 889 if not unknown: |
| 60 | 890 return None |
| 324 | 891 |
| 892 rep = {} | |
| 893 reqcnt = 0 | |
| 515 | 894 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
895 # search through remote branches |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
896 # 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
|
897 # head, root, first parent, second parent |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
898 # (a branch always has two parents (or none) by definition) |
| 222 | 899 unknown = remote.branches(unknown) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
900 while unknown: |
| 324 | 901 r = [] |
| 902 while unknown: | |
| 903 n = unknown.pop(0) | |
| 904 if n[0] in seen: | |
| 905 continue | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
906 |
| 324 | 907 self.ui.debug("examining %s:%s\n" % (short(n[0]), short(n[1]))) |
| 908 if n[0] == nullid: | |
| 909 break | |
| 328 | 910 if n in seenbranch: |
| 324 | 911 self.ui.debug("branch already found\n") |
| 912 continue | |
| 913 if n[1] and n[1] in m: # do we know the base? | |
| 914 self.ui.debug("found incomplete branch %s:%s\n" | |
| 915 % (short(n[0]), short(n[1]))) | |
| 916 search.append(n) # schedule branch range for scanning | |
| 328 | 917 seenbranch[n] = 1 |
| 324 | 918 else: |
| 919 if n[1] not in seen and n[1] not in fetch: | |
| 920 if n[2] in m and n[3] in m: | |
| 921 self.ui.debug("found new changeset %s\n" % | |
| 922 short(n[1])) | |
| 923 fetch.append(n[1]) # earliest unknown | |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
924 base[n[2]] = 1 # latest known |
| 324 | 925 continue |
| 926 | |
| 927 for a in n[2:4]: | |
| 928 if a not in rep: | |
| 929 r.append(a) | |
| 930 rep[a] = 1 | |
| 931 | |
| 328 | 932 seen[n[0]] = 1 |
| 933 | |
| 324 | 934 if r: |
| 935 reqcnt += 1 | |
| 936 self.ui.debug("request %d: %s\n" % | |
| 937 (reqcnt, " ".join(map(short, r)))) | |
| 938 for p in range(0, len(r), 10): | |
| 939 for b in remote.branches(r[p:p+10]): | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
940 self.ui.debug("received %s:%s\n" % |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
941 (short(b[0]), short(b[1]))) |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
942 if b[0] not in m and b[0] not in seen: |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
943 unknown.append(b) |
| 515 | 944 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
945 # 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
|
946 while search: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
947 n = search.pop(0) |
| 324 | 948 reqcnt += 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
949 l = remote.between([(n[0], n[1])])[0] |
| 328 | 950 l.append(n[1]) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
951 p = n[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
952 f = 1 |
| 328 | 953 for i in l: |
| 954 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
|
955 if i in m: |
| 85 | 956 if f <= 2: |
| 83 | 957 self.ui.debug("found new branch changeset %s\n" % |
| 958 short(p)) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
959 fetch.append(p) |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
960 base[i] = 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
961 else: |
| 83 | 962 self.ui.debug("narrowed branch search to %s:%s\n" |
| 963 % (short(p), short(i))) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
964 search.append((p, i)) |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
965 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
966 p, f = i, f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
967 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
968 # sanity check our fetch list |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
969 for f in fetch: |
|
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
970 if f in m: |
| 499 | 971 raise RepoError("already have changeset " + short(f[:4])) |
| 83 | 972 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
973 if base.keys() == [nullid]: |
|
514
874e577e332e
change unrelated repository error to a warning
mpm@selenic.com
parents:
511
diff
changeset
|
974 self.ui.warn("warning: pulling from an unrelated repository!\n") |
| 511 | 975 |
| 94 | 976 self.ui.note("adding new changesets starting at " + |
| 83 | 977 " ".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
|
978 |
| 324 | 979 self.ui.debug("%d total queries\n" % reqcnt) |
| 980 | |
| 516 | 981 return fetch |
| 982 | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
983 def findoutgoing(self, remote): |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
984 base = {} |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
985 findincoming(self, remote, base) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
986 remain = dict.fromkeys(self.changelog.nodemap) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
987 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
988 # prune everything remote has from the tree |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
989 remove = base.keys() |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
990 while remove: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
991 n = remove.pop(0) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
992 if n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
993 del remain[n] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
994 for p in self.changelog.parents(n): |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
995 remain.append(p) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
996 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
997 # 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
|
998 subset = [] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
999 for n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1000 p1, p2 = self.changelog.parents(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1001 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
|
1002 subset.append(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1003 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1004 # 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
|
1005 return subset |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1006 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1007 def pull(self, remote): |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1008 lock = self.lock() |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1009 fetch = self.findincoming(remote) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1010 if not fetch: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1011 self.ui.status("no changes found\n") |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1012 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1013 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1014 cg = remote.changegroup(fetch) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1015 return self.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1016 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1017 def push(self, remote): |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1018 lock = remote.lock() |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1019 update = self.findoutgoing(remote) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1020 if not update: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1021 self.ui.status("no changes found\n") |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1022 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1023 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1024 cg = self.changegroup(update) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1025 return remote.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1026 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1027 def changegroup(self, basenodes): |
| 222 | 1028 class genread: |
| 1029 def __init__(self, generator): | |
| 1030 self.g = generator | |
| 1031 self.buf = "" | |
| 1032 def read(self, l): | |
| 1033 while l > len(self.buf): | |
| 1034 try: | |
| 1035 self.buf += self.g.next() | |
| 1036 except StopIteration: | |
| 1037 break | |
| 1038 d, self.buf = self.buf[:l], self.buf[l:] | |
| 1039 return d | |
| 515 | 1040 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1041 def gengroup(): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1042 nodes = self.newer(basenodes) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1043 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1044 # construct the link map |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1045 linkmap = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1046 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1047 linkmap[self.changelog.rev(n)] = n |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1048 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1049 # construct a list of all changed files |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1050 changed = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1051 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1052 c = self.changelog.read(n) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1053 for f in c[3]: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1054 changed[f] = 1 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1055 changed = changed.keys() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1056 changed.sort() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1057 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1058 # the changegroup is changesets + manifests + all file revs |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1059 revs = [ self.changelog.rev(n) for n in nodes ] |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1060 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1061 for y in self.changelog.group(linkmap): yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1062 for y in self.manifest.group(linkmap): yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1063 for f in changed: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1064 yield struct.pack(">l", len(f) + 4) + f |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1065 g = self.file(f).group(linkmap) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1066 for y in g: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1067 yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1068 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1069 yield struct.pack(">l", 0) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1070 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1071 return genread(gengroup()) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1072 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1073 def addchangegroup(self, source): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1074 |
| 222 | 1075 def getchunk(): |
| 1076 d = source.read(4) | |
| 1077 if not d: return "" | |
| 1078 l = struct.unpack(">l", d)[0] | |
| 1079 if l <= 4: return "" | |
| 1080 return source.read(l - 4) | |
| 1081 | |
| 1082 def getgroup(): | |
| 1083 while 1: | |
| 1084 c = getchunk() | |
| 1085 if not c: break | |
| 1086 yield c | |
| 1087 | |
| 1088 def csmap(x): | |
| 1089 self.ui.debug("add changeset %s\n" % short(x)) | |
| 1090 return self.changelog.count() | |
| 1091 | |
| 1092 def revmap(x): | |
| 1093 return self.changelog.rev(x) | |
| 1094 | |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1095 if not source: return |
| 222 | 1096 changesets = files = revisions = 0 |
| 225 | 1097 |
| 222 | 1098 tr = self.transaction() |
| 1099 | |
| 1100 # pull off the changeset group | |
| 1101 self.ui.status("adding changesets\n") | |
| 1102 co = self.changelog.tip() | |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
223
diff
changeset
|
1103 cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique |
| 222 | 1104 changesets = self.changelog.rev(cn) - self.changelog.rev(co) |
| 1105 | |
| 1106 # pull off the manifest group | |
| 1107 self.ui.status("adding manifests\n") | |
| 1108 mm = self.manifest.tip() | |
| 1109 mo = self.manifest.addgroup(getgroup(), revmap, tr) | |
| 1110 | |
| 1111 # process the files | |
| 1112 self.ui.status("adding file revisions\n") | |
| 1113 while 1: | |
| 1114 f = getchunk() | |
| 1115 if not f: break | |
| 1116 self.ui.debug("adding %s revisions\n" % f) | |
| 1117 fl = self.file(f) | |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1118 o = fl.count() |
| 222 | 1119 n = fl.addgroup(getgroup(), revmap, tr) |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1120 revisions += fl.count() - o |
| 222 | 1121 files += 1 |
| 1122 | |
| 1123 self.ui.status(("modified %d files, added %d changesets" + | |
| 1124 " and %d new revisions\n") | |
| 1125 % (files, changesets, revisions)) | |
| 1126 | |
| 1127 tr.close() | |
| 1128 return | |
| 1129 | |
| 588 | 1130 def update(self, node, allow=False, force=False, choose=None, |
| 1131 moddirstate=True): | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1132 pl = self.dirstate.parents() |
| 275 | 1133 if not force and pl[1] != nullid: |
| 254 | 1134 self.ui.warn("aborting: outstanding uncommitted merges\n") |
| 46 | 1135 return |
| 1136 | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1137 p1, p2 = pl[0], node |
| 305 | 1138 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
|
1139 m1n = self.changelog.read(p1)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1140 m2n = self.changelog.read(p2)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1141 man = self.manifest.ancestor(m1n, m2n) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1142 m1 = self.manifest.read(m1n) |
| 276 | 1143 mf1 = self.manifest.readflags(m1n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1144 m2 = self.manifest.read(m2n) |
| 276 | 1145 mf2 = self.manifest.readflags(m2n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1146 ma = self.manifest.read(man) |
| 412 | 1147 mfa = self.manifest.readflags(man) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1148 |
| 536 | 1149 (c, a, d, u) = self.changes(None, None) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1150 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1151 # 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
|
1152 # from p1 to p2? |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1153 linear_path = (pa == p1 or pa == p2) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1154 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1155 # 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
|
1156 # we care about merging |
| 254 | 1157 self.ui.note("resolving manifests\n") |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1158 self.ui.debug(" ancestor %s local %s remote %s\n" % |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1159 (short(man), short(m1n), short(m2n))) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1160 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1161 merge = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1162 get = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1163 remove = [] |
| 305 | 1164 mark = {} |
| 46 | 1165 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1166 # construct a working dir manifest |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1167 mw = m1.copy() |
| 276 | 1168 mfw = mf1.copy() |
| 576 | 1169 umap = dict.fromkeys(u) |
| 1170 | |
| 254 | 1171 for f in a + c + u: |
| 1172 mw[f] = "" | |
| 441 | 1173 mfw[f] = util.is_exec(self.wjoin(f), mfw.get(f, False)) |
| 576 | 1174 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1175 for f in d: |
| 254 | 1176 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
|
1177 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1178 # 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
|
1179 # 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
|
1180 # 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
|
1181 # 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
|
1182 # longer in the manifest. |
| 588 | 1183 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
|
1184 self.dirstate.forget((f,)) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1185 |
| 576 | 1186 # Compare manifests |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1187 for f, n in mw.iteritems(): |
| 588 | 1188 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
|
1189 if f in m2: |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1190 s = 0 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1191 |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1192 # is the wfile new since m1, and match m2? |
| 428 | 1193 if f not in m1: |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1194 t1 = self.wfile(f).read() |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1195 t2 = self.file(f).revision(m2[f]) |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1196 if cmp(t1, t2) == 0: |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1197 mark[f] = 1 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1198 n = m2[f] |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1199 del t1, t2 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1200 |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1201 # are files different? |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1202 if n != m2[f]: |
| 254 | 1203 a = ma.get(f, nullid) |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1204 # are both different from the ancestor? |
| 254 | 1205 if n != a and m2[f] != a: |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1206 self.ui.debug(" %s versions differ, resolve\n" % f) |
| 276 | 1207 # merge executable bits |
| 1208 # "if we changed or they changed, change in merge" | |
| 1209 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] | |
| 1210 mode = ((a^b) | (a^c)) ^ a | |
| 1211 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
|
1212 s = 1 |
| 305 | 1213 # are we clobbering? |
| 1214 # is remote's version newer? | |
| 1215 # or are we going back in time? | |
| 1216 elif force or m2[f] != a or (p2 == pa and mw[f] == m1[f]): | |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1217 self.ui.debug(" remote %s is newer, get\n" % f) |
| 254 | 1218 get[f] = m2[f] |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1219 s = 1 |
| 305 | 1220 else: |
| 1221 mark[f] = 1 | |
| 576 | 1222 elif f in umap: |
| 1223 # this unknown file is the same as the checkout | |
| 1224 get[f] = m2[f] | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1225 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1226 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
|
1227 if force: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1228 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1229 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
|
1230 else: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1231 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
|
1232 mode = ((a^b) | (a^c)) ^ a |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1233 if mode != b: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1234 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1235 util.set_exec(self.wjoin(f), mode) |
| 305 | 1236 mark[f] = 1 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1237 del m2[f] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1238 elif f in ma: |
| 616 | 1239 if n != ma[f]: |
| 1240 r = "d" | |
| 1241 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
|
1242 r = self.ui.prompt( |
|
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
|
1243 (" local changed %s which remote deleted\n" % f) + |
|
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
|
1244 "(k)eep or (d)elete?", "[kd]", "k") |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1245 if r == "d": |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1246 remove.append(f) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1247 else: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1248 self.ui.debug("other deleted %s\n" % f) |
| 254 | 1249 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
|
1250 else: |
| 254 | 1251 if n == m1.get(f, nullid): # same as parent |
|
383
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1252 if p2 == pa: # going backwards? |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1253 self.ui.debug("remote deleted %s\n" % f) |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1254 remove.append(f) |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1255 else: |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1256 self.ui.debug("local created %s, keeping\n" % f) |
| 254 | 1257 else: |
| 1258 self.ui.debug("working dir created %s, keeping\n" % f) | |
| 46 | 1259 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1260 for f, n in m2.iteritems(): |
| 588 | 1261 if choose and not choose(f): continue |
| 256 | 1262 if f[0] == "/": continue |
| 616 | 1263 if f in ma and n != ma[f]: |
| 1264 r = "k" | |
| 1265 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
|
1266 r = self.ui.prompt( |
|
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
|
1267 ("remote changed %s which local deleted\n" % f) + |
|
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
|
1268 "(k)eep or (d)elete?", "[kd]", "k") |
| 616 | 1269 if r == "k": get[f] = n |
| 1270 elif f not in ma: | |
| 254 | 1271 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
|
1272 get[f] = n |
| 616 | 1273 else: |
| 1274 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
|
1275 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1276 del mw, m1, m2, ma |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1277 |
| 275 | 1278 if force: |
| 1279 for f in merge: | |
| 1280 get[f] = merge[f][1] | |
| 1281 merge = {} | |
| 1282 | |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1283 if linear_path: |
| 254 | 1284 # we don't need to do any magic, just jump to the new rev |
| 1285 mode = 'n' | |
| 1286 p1, p2 = p2, nullid | |
| 1287 else: | |
| 275 | 1288 if not allow: |
| 305 | 1289 self.ui.status("this update spans a branch" + |
| 1290 " affecting the following files:\n") | |
| 1291 fl = merge.keys() + get.keys() | |
| 1292 fl.sort() | |
| 1293 for f in fl: | |
| 1294 cf = "" | |
| 1295 if f in merge: cf = " (resolve)" | |
| 1296 self.ui.status(" %s%s\n" % (f, cf)) | |
| 1297 self.ui.warn("aborting update spanning branches!\n") | |
| 1298 self.ui.status("(use update -m to perform a branch merge)\n") | |
| 275 | 1299 return 1 |
| 254 | 1300 # we have to remember what files we needed to get/change |
| 1301 # because any file that's different from either one of its | |
| 1302 # parents must be in the changeset | |
| 1303 mode = 'm' | |
| 588 | 1304 if moddirstate: |
| 1305 self.dirstate.update(mark.keys(), "m") | |
| 254 | 1306 |
| 588 | 1307 if moddirstate: |
| 1308 self.dirstate.setparents(p1, p2) | |
|
191
d7e859cf2f1b
merge: add count of new manifests, files, and revisions
mpm@selenic.com
parents:
190
diff
changeset
|
1309 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1310 # 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
|
1311 files = get.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1312 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1313 for f in files: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1314 if f[0] == "/": continue |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1315 self.ui.note("getting %s\n" % f) |
| 276 | 1316 t = self.file(f).read(get[f]) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1317 try: |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1318 self.wfile(f, "w").write(t) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1319 except IOError: |
|
297
0dbcf3c9ff20
Fixed usage of removed variable 'wp'.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
292
diff
changeset
|
1320 os.makedirs(os.path.dirname(self.wjoin(f))) |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1321 self.wfile(f, "w").write(t) |
| 441 | 1322 util.set_exec(self.wjoin(f), mf2[f]) |
| 588 | 1323 if moddirstate: |
| 1324 self.dirstate.update([f], mode) | |
| 46 | 1325 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1326 # merge the tricky bits |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1327 files = merge.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1328 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1329 for f in files: |
| 256 | 1330 self.ui.status("merging %s\n" % f) |
| 276 | 1331 m, o, flag = merge[f] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1332 self.merge3(f, m, o) |
| 441 | 1333 util.set_exec(self.wjoin(f), flag) |
| 588 | 1334 if moddirstate: |
| 1335 self.dirstate.update([f], 'm') | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1336 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1337 for f in remove: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1338 self.ui.note("removing %s\n" % f) |
| 254 | 1339 os.unlink(f) |
| 578 | 1340 # try removing directories that might now be empty |
| 1341 try: os.removedirs(os.path.dirname(f)) | |
| 1342 except: pass | |
| 588 | 1343 if moddirstate: |
| 1344 if mode == 'n': | |
| 1345 self.dirstate.forget(remove) | |
| 1346 else: | |
| 1347 self.dirstate.update(remove, 'r') | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1348 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1349 def merge3(self, fn, my, other): |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1350 """perform a 3-way merge in the working directory""" |
| 249 | 1351 |
| 96 | 1352 def temp(prefix, node): |
| 1353 pre = "%s~%s." % (os.path.basename(fn), prefix) | |
| 1354 (fd, name) = tempfile.mkstemp("", pre) | |
| 417 | 1355 f = os.fdopen(fd, "wb") |
| 96 | 1356 f.write(fl.revision(node)) |
| 1357 f.close() | |
| 1358 return name | |
| 1359 | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1360 fl = self.file(fn) |
| 96 | 1361 base = fl.ancestor(my, other) |
| 244 | 1362 a = self.wjoin(fn) |
| 346 | 1363 b = temp("base", base) |
| 1364 c = temp("other", other) | |
| 96 | 1365 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1366 self.ui.note("resolving %s\n" % fn) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1367 self.ui.debug("file %s: other %s ancestor %s\n" % |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1368 (fn, short(other), short(base))) |
| 96 | 1369 |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
1370 cmd = self.ui.config("ui", "merge") or \ |
|
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
1371 os.environ.get("HGMERGE", "hgmerge") |
| 240 | 1372 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
|
1373 if r: |
| 275 | 1374 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
|
1375 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1376 os.unlink(b) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1377 os.unlink(c) |
| 96 | 1378 |
| 247 | 1379 def verify(self): |
| 1380 filelinkrevs = {} | |
| 1381 filenodes = {} | |
| 1382 changesets = revisions = files = 0 | |
| 1383 errors = 0 | |
| 1384 | |
| 302 | 1385 seen = {} |
| 247 | 1386 self.ui.status("checking changesets\n") |
| 1387 for i in range(self.changelog.count()): | |
| 1388 changesets += 1 | |
| 1389 n = self.changelog.node(i) | |
| 302 | 1390 if n in seen: |
| 1391 self.ui.warn("duplicate changeset at revision %d\n" % i) | |
| 1392 errors += 1 | |
| 1393 seen[n] = 1 | |
| 515 | 1394 |
| 247 | 1395 for p in self.changelog.parents(n): |
| 1396 if p not in self.changelog.nodemap: | |
| 1397 self.ui.warn("changeset %s has unknown parent %s\n" % | |
| 1398 (short(n), short(p))) | |
| 1399 errors += 1 | |
| 1400 try: | |
| 1401 changes = self.changelog.read(n) | |
| 1402 except Exception, inst: | |
| 1403 self.ui.warn("unpacking changeset %s: %s\n" % (short(n), inst)) | |
| 1404 errors += 1 | |
| 1405 | |
| 1406 for f in changes[3]: | |
| 1407 filelinkrevs.setdefault(f, []).append(i) | |
| 1408 | |
| 302 | 1409 seen = {} |
| 247 | 1410 self.ui.status("checking manifests\n") |
| 1411 for i in range(self.manifest.count()): | |
| 1412 n = self.manifest.node(i) | |
| 302 | 1413 if n in seen: |
| 1414 self.ui.warn("duplicate manifest at revision %d\n" % i) | |
| 1415 errors += 1 | |
| 1416 seen[n] = 1 | |
| 515 | 1417 |
| 247 | 1418 for p in self.manifest.parents(n): |
| 1419 if p not in self.manifest.nodemap: | |
| 1420 self.ui.warn("manifest %s has unknown parent %s\n" % | |
| 1421 (short(n), short(p))) | |
| 1422 errors += 1 | |
| 1423 | |
| 1424 try: | |
| 1425 delta = mdiff.patchtext(self.manifest.delta(n)) | |
| 1426 except KeyboardInterrupt: | |
| 582 | 1427 self.ui.warn("aborted") |
| 247 | 1428 sys.exit(0) |
| 1429 except Exception, inst: | |
| 1430 self.ui.warn("unpacking manifest %s: %s\n" | |
| 1431 % (short(n), inst)) | |
| 1432 errors += 1 | |
| 1433 | |
| 1434 ff = [ l.split('\0') for l in delta.splitlines() ] | |
| 1435 for f, fn in ff: | |
| 284 | 1436 filenodes.setdefault(f, {})[bin(fn[:40])] = 1 |
| 247 | 1437 |
| 1438 self.ui.status("crosschecking files in changesets and manifests\n") | |
| 1439 for f in filenodes: | |
| 1440 if f not in filelinkrevs: | |
| 1441 self.ui.warn("file %s in manifest but not in changesets\n" % f) | |
| 1442 errors += 1 | |
| 1443 | |
| 1444 for f in filelinkrevs: | |
| 1445 if f not in filenodes: | |
| 1446 self.ui.warn("file %s in changeset but not in manifest\n" % f) | |
| 1447 errors += 1 | |
| 1448 | |
| 1449 self.ui.status("checking files\n") | |
| 1450 ff = filenodes.keys() | |
| 1451 ff.sort() | |
| 1452 for f in ff: | |
| 1453 if f == "/dev/null": continue | |
| 1454 files += 1 | |
| 1455 fl = self.file(f) | |
| 1456 nodes = { nullid: 1 } | |
| 302 | 1457 seen = {} |
| 247 | 1458 for i in range(fl.count()): |
| 1459 revisions += 1 | |
| 1460 n = fl.node(i) | |
| 1461 | |
| 302 | 1462 if n in seen: |
| 1463 self.ui.warn("%s: duplicate revision %d\n" % (f, i)) | |
| 1464 errors += 1 | |
| 1465 | |
| 247 | 1466 if n not in filenodes[f]: |
| 1467 self.ui.warn("%s: %d:%s not in manifests\n" | |
| 1468 % (f, i, short(n))) | |
| 1469 errors += 1 | |
| 1470 else: | |
| 1471 del filenodes[f][n] | |
| 1472 | |
| 1473 flr = fl.linkrev(n) | |
| 1474 if flr not in filelinkrevs[f]: | |
| 1475 self.ui.warn("%s:%s points to unexpected changeset %d\n" | |
| 1476 % (f, short(n), fl.linkrev(n))) | |
| 1477 errors += 1 | |
| 1478 else: | |
| 1479 filelinkrevs[f].remove(flr) | |
| 1480 | |
| 1481 # verify contents | |
| 1482 try: | |
| 1483 t = fl.read(n) | |
| 1484 except Exception, inst: | |
| 1485 self.ui.warn("unpacking file %s %s: %s\n" | |
| 1486 % (f, short(n), inst)) | |
| 1487 errors += 1 | |
| 1488 | |
| 1489 # verify parents | |
| 1490 (p1, p2) = fl.parents(n) | |
| 1491 if p1 not in nodes: | |
| 1492 self.ui.warn("file %s:%s unknown parent 1 %s" % | |
| 1493 (f, short(n), short(p1))) | |
| 1494 errors += 1 | |
| 1495 if p2 not in nodes: | |
| 1496 self.ui.warn("file %s:%s unknown parent 2 %s" % | |
| 1497 (f, short(n), short(p1))) | |
| 1498 errors += 1 | |
| 1499 nodes[n] = 1 | |
| 1500 | |
| 1501 # cross-check | |
| 1502 for node in filenodes[f]: | |
| 1503 self.ui.warn("node %s in manifests not in %s\n" | |
| 1504 % (hex(n), f)) | |
| 1505 errors += 1 | |
| 1506 | |
| 1507 self.ui.status("%d files, %d changesets, %d total revisions\n" % | |
| 1508 (files, changesets, revisions)) | |
| 1509 | |
| 1510 if errors: | |
| 1511 self.ui.warn("%d integrity errors encountered!\n" % errors) | |
| 1512 return 1 | |
| 1513 | |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1514 class httprepository: |
| 60 | 1515 def __init__(self, ui, path): |
|
176
1d8e9637a0a4
Change hg: protocol name to http: and http: to old-http:
mpm@selenic.com
parents:
171
diff
changeset
|
1516 self.url = path |
| 60 | 1517 self.ui = ui |
| 321 | 1518 no_list = [ "localhost", "127.0.0.1" ] |
| 1519 host = ui.config("http_proxy", "host") | |
|
424
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1520 if host is None: |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1521 host = os.environ.get("http_proxy") |
|
426
8c90ab5644c9
Allow hgrc's proxy host and $http_proxy env var to start with http://
Thomas Arendsen Hein <thomas@intevation.de>
parents:
424
diff
changeset
|
1522 if host and host.startswith('http://'): |
|
8c90ab5644c9
Allow hgrc's proxy host and $http_proxy env var to start with http://
Thomas Arendsen Hein <thomas@intevation.de>
parents:
424
diff
changeset
|
1523 host = host[7:] |
| 321 | 1524 user = ui.config("http_proxy", "user") |
| 1525 passwd = ui.config("http_proxy", "passwd") | |
| 1526 no = ui.config("http_proxy", "no") | |
|
424
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1527 if no is None: |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1528 no = os.environ.get("no_proxy") |
| 321 | 1529 if no: |
| 1530 no_list = no_list + no.split(",") | |
| 515 | 1531 |
| 321 | 1532 no_proxy = 0 |
| 1533 for h in no_list: | |
| 1534 if (path.startswith("http://" + h + "/") or | |
| 1535 path.startswith("http://" + h + ":") or | |
| 1536 path == "http://" + h): | |
| 1537 no_proxy = 1 | |
| 1538 | |
| 1539 # Note: urllib2 takes proxy values from the environment and those will | |
| 1540 # take precedence | |
|
424
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1541 for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]: |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1542 if os.environ.has_key(env): |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1543 del os.environ[env] |
| 321 | 1544 |
| 1545 proxy_handler = urllib2.BaseHandler() | |
| 1546 if host and not no_proxy: | |
| 1547 proxy_handler = urllib2.ProxyHandler({"http" : "http://" + host}) | |
| 1548 | |
| 1549 authinfo = None | |
| 1550 if user and passwd: | |
| 1551 passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm() | |
| 1552 passmgr.add_password(None, host, user, passwd) | |
| 1553 authinfo = urllib2.ProxyBasicAuthHandler(passmgr) | |
| 1554 | |
| 1555 opener = urllib2.build_opener(proxy_handler, authinfo) | |
| 1556 urllib2.install_opener(opener) | |
| 60 | 1557 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1558 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1559 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1560 |
| 60 | 1561 def do_cmd(self, cmd, **args): |
| 83 | 1562 self.ui.debug("sending %s command\n" % cmd) |
| 60 | 1563 q = {"cmd": cmd} |
| 1564 q.update(args) | |
| 1565 qs = urllib.urlencode(q) | |
| 1566 cu = "%s?%s" % (self.url, qs) | |
| 321 | 1567 return urllib2.urlopen(cu) |
| 60 | 1568 |
| 222 | 1569 def heads(self): |
| 1570 d = self.do_cmd("heads").read() | |
| 1571 try: | |
| 1572 return map(bin, d[:-1].split(" ")) | |
| 1573 except: | |
| 1574 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 1575 raise | |
| 1576 | |
| 60 | 1577 def branches(self, nodes): |
| 1578 n = " ".join(map(hex, nodes)) | |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1579 d = self.do_cmd("branches", nodes=n).read() |
| 217 | 1580 try: |
| 1581 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ] | |
| 1582 return br | |
| 1583 except: | |
| 1584 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 1585 raise | |
| 60 | 1586 |
| 1587 def between(self, pairs): | |
| 1588 n = "\n".join(["-".join(map(hex, p)) for p in pairs]) | |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1589 d = self.do_cmd("between", pairs=n).read() |
| 217 | 1590 try: |
| 1591 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ] | |
| 1592 return p | |
| 1593 except: | |
| 1594 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 1595 raise | |
| 60 | 1596 |
| 1597 def changegroup(self, nodes): | |
| 1598 n = " ".join(map(hex, nodes)) | |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1599 f = self.do_cmd("changegroup", roots=n) |
| 192 | 1600 bytes = 0 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1601 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1602 class zread: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1603 def __init__(self, f): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1604 self.zd = zlib.decompressobj() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1605 self.f = f |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1606 self.buf = "" |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1607 def read(self, l): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1608 while l > len(self.buf): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1609 r = f.read(4096) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1610 if r: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1611 self.buf += self.zd.decompress(r) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1612 else: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1613 self.buf += self.zd.flush() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1614 break |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1615 d, self.buf = self.buf[:l], self.buf[l:] |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1616 return d |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1617 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1618 return zread(f) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1619 |
| 60 | 1620 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1621 class sshrepository: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1622 def __init__(self, ui, path): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1623 self.url = path |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1624 self.ui = ui |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1625 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1626 m = re.match(r'ssh://(([^@]+)@)?([^:/]+)(:(\d+))?(/(.*))?', path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1627 if not m: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1628 raise RepoError("couldn't parse destination %s\n" % path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1629 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1630 self.user = m.group(2) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1631 self.host = m.group(3) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1632 self.port = m.group(5) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1633 self.path = m.group(7) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1634 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1635 args = self.user and ("%s@%s" % (self.user, self.host)) or self.host |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1636 args = self.port and ("%s -p %s") % (args, self.port) or args |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1637 path = self.path or "" |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1638 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1639 cmd = "ssh %s 'hg -R %s serve --stdio'" |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1640 cmd = cmd % (args, path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1641 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1642 self.pipeo, self.pipei = os.popen2(cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1643 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1644 def __del__(self): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1645 self.pipeo.close() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1646 self.pipei.close() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1647 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1648 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1649 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1650 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1651 def do_cmd(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1652 self.ui.debug("sending %s command\n" % cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1653 self.pipeo.write("%s\n" % cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1654 for k, v in args.items(): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1655 self.pipeo.write("%s %d\n" % (k, len(v))) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1656 self.pipeo.write(v) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1657 self.pipeo.flush() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1658 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1659 return self.pipei |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1660 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1661 def call(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1662 r = self.do_cmd(cmd, **args) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1663 l = int(r.readline()) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1664 return r.read(l) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1665 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1666 def heads(self): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1667 d = self.call("heads") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1668 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1669 return map(bin, d[:-1].split(" ")) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1670 except: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1671 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1672 raise |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1673 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1674 def branches(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1675 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1676 d = self.call("branches", nodes=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1677 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1678 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ] |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1679 return br |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1680 except: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1681 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1682 raise |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1683 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1684 def between(self, pairs): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1685 n = "\n".join(["-".join(map(hex, p)) for p in pairs]) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1686 d = self.call("between", pairs=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1687 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1688 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ] |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1689 return p |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1690 except: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1691 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1692 raise |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1693 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1694 def changegroup(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1695 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1696 f = self.do_cmd("changegroup", roots=n) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1697 return self.pipei |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1698 |
| 60 | 1699 def repository(ui, path=None, create=0): |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1700 if path: |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1701 if path.startswith("http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1702 return httprepository(ui, path) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1703 if path.startswith("hg://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1704 return httprepository(ui, path.replace("hg://", "http://")) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1705 if path.startswith("old-http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1706 return localrepository(ui, path.replace("old-http://", "http://")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1707 if path.startswith("ssh://"): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1708 return sshrepository(ui, path) |
| 60 | 1709 |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1710 return localrepository(ui, path, create) |