Mercurial > hg > mercurial-crew-with-dirclash
annotate mercurial/hg.py @ 990:5007e0bdeed2
Fix long-standing excessive file merges
Since switching to the multihead approach, we've been creating
excessive file-level merges where files are marked as merged with
their ancestors.
This explicitly checks at commit time whether the two parent versions
are linearly related, and if so, reduces the file check-in to a
non-merge. Then the file is compared against the remaining parent,
and, if equal, skips check-in of that file (as it's not changed).
Since we're not checking in all files that were different between
versions, we no longer need to mark so many files for merge. This
removes most of the 'm' state marking as well.
Finally, it is possible to do a tree-level merge with no file-level
changes. This will happen if one user changes file A and another
changes file B. Thus, if we have have two parents, we allow commit to
proceed even if there are no file-level changes.
| author | mpm@selenic.com |
|---|---|
| date | Sun, 21 Aug 2005 21:59:55 -0700 |
| parents | 4f81068ed8cd |
| children | b634b15c020b |
| 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") | |
| 765 | 13 demandload(globals(), "tempfile httprangereader bdiff urlparse") |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
14 demandload(globals(), "bisect errno select stat") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
15 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
16 class filelog(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
17 def __init__(self, opener, path): |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
18 revlog.__init__(self, opener, |
|
786
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
19 os.path.join("data", self.encodedir(path + ".i")), |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
20 os.path.join("data", self.encodedir(path + ".d"))) |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
21 |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
22 # This avoids a collision between a file named foo and a dir named |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
23 # foo.i or foo.d |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
24 def encodedir(self, path): |
|
856
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
25 return (path |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
26 .replace(".hg/", ".hg.hg/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
27 .replace(".i/", ".i.hg/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
28 .replace(".d/", ".d.hg/")) |
|
786
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
29 |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
30 def decodedir(self, path): |
|
856
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
31 return (path |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
32 .replace(".d.hg/", ".d/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
33 .replace(".i.hg/", ".i/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
34 .replace(".hg.hg/", ".hg/")) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
35 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
36 def read(self, node): |
| 360 | 37 t = self.revision(node) |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
38 if not t.startswith('\1\n'): |
| 360 | 39 return t |
| 40 s = t.find('\1\n', 2) | |
| 41 return t[s+2:] | |
| 42 | |
| 43 def readmeta(self, node): | |
| 44 t = self.revision(node) | |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
45 if not t.startswith('\1\n'): |
| 360 | 46 return t |
| 47 s = t.find('\1\n', 2) | |
| 48 mt = t[2:s] | |
| 49 for l in mt.splitlines(): | |
| 50 k, v = l.split(": ", 1) | |
| 51 m[k] = v | |
| 52 return m | |
| 53 | |
| 54 def add(self, text, meta, transaction, link, p1=None, p2=None): | |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
55 if meta or text.startswith('\1\n'): |
| 360 | 56 mt = "" |
| 57 if meta: | |
| 58 mt = [ "%s: %s\n" % (k, v) for k,v in meta.items() ] | |
| 59 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
|
60 return self.addrevision(text, transaction, link, p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
61 |
| 79 | 62 def annotate(self, node): |
| 199 | 63 |
| 64 def decorate(text, rev): | |
| 436 | 65 return ([rev] * len(text.splitlines()), text) |
| 199 | 66 |
| 67 def pair(parent, child): | |
| 436 | 68 for a1, a2, b1, b2 in bdiff.blocks(parent[1], child[1]): |
| 471 | 69 child[0][b1:b2] = parent[0][a1:a2] |
| 70 return child | |
| 199 | 71 |
| 200 | 72 # find all ancestors |
|
216
201115f2859b
hg annotate: actually annotate the given version
mpm@selenic.com
parents:
210
diff
changeset
|
73 needed = {node:1} |
| 199 | 74 visit = [node] |
| 75 while visit: | |
| 76 n = visit.pop(0) | |
| 77 for p in self.parents(n): | |
| 78 if p not in needed: | |
| 79 needed[p] = 1 | |
| 80 visit.append(p) | |
| 200 | 81 else: |
| 82 # count how many times we'll use this | |
| 83 needed[p] += 1 | |
| 199 | 84 |
| 200 | 85 # sort by revision which is a topological order |
| 471 | 86 visit = [ (self.rev(n), n) for n in needed.keys() ] |
| 199 | 87 visit.sort() |
| 88 hist = {} | |
| 89 | |
| 471 | 90 for r,n in visit: |
| 199 | 91 curr = decorate(self.read(n), self.linkrev(n)) |
| 92 for p in self.parents(n): | |
| 93 if p != nullid: | |
| 94 curr = pair(hist[p], curr) | |
| 200 | 95 # trim the history of unneeded revs |
| 96 needed[p] -= 1 | |
| 97 if not needed[p]: | |
| 98 del hist[p] | |
| 199 | 99 hist[n] = curr |
| 100 | |
| 436 | 101 return zip(hist[n][0], hist[n][1].splitlines(1)) |
| 79 | 102 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
103 class manifest(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
104 def __init__(self, opener): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
105 self.mapcache = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
106 self.listcache = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
107 self.addlist = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
108 revlog.__init__(self, opener, "00manifest.i", "00manifest.d") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
109 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
110 def read(self, node): |
| 313 | 111 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
|
112 if self.mapcache and self.mapcache[0] == node: |
| 561 | 113 return self.mapcache[1] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
114 text = self.revision(node) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
115 map = {} |
| 276 | 116 flag = {} |
|
25
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
117 self.listcache = (text, text.splitlines(1)) |
|
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
118 for l in self.listcache[1]: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
119 (f, n) = l.split('\0') |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
120 map[f] = bin(n[:40]) |
| 276 | 121 flag[f] = (n[40:-1] == "x") |
| 122 self.mapcache = (node, map, flag) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
123 return map |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
124 |
| 276 | 125 def readflags(self, node): |
| 313 | 126 if node == nullid: return {} # don't upset local cache |
|
358
9f4077d7ef6f
[PATCH] manifest.readflags performance buglet
mpm@selenic.com
parents:
350
diff
changeset
|
127 if not self.mapcache or self.mapcache[0] != node: |
| 276 | 128 self.read(node) |
| 129 return self.mapcache[2] | |
| 130 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
131 def diff(self, a, b): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
132 # this is sneaky, as we're not actually using a and b |
| 140 | 133 if self.listcache and self.addlist and self.listcache[0] == a: |
| 98 | 134 d = mdiff.diff(self.listcache[1], self.addlist, 1) |
| 135 if mdiff.patch(a, d) != b: | |
| 136 sys.stderr.write("*** sortdiff failed, falling back ***\n") | |
| 137 return mdiff.textdiff(a, b) | |
| 138 return d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
139 else: |
| 44 | 140 return mdiff.textdiff(a, b) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
141 |
| 741 | 142 def add(self, map, flags, transaction, link, p1=None, p2=None, |
| 143 changed=None): | |
| 644 | 144 # directly generate the mdiff delta from the data collected during |
| 145 # the bisect loop below | |
| 146 def gendelta(delta): | |
| 147 i = 0 | |
| 148 result = [] | |
| 149 while i < len(delta): | |
| 150 start = delta[i][2] | |
| 151 end = delta[i][3] | |
| 152 l = delta[i][4] | |
| 153 if l == None: | |
| 154 l = "" | |
| 741 | 155 while i < len(delta) - 1 and start <= delta[i+1][2] \ |
| 156 and end >= delta[i+1][2]: | |
| 644 | 157 if delta[i+1][3] > end: |
| 158 end = delta[i+1][3] | |
| 159 if delta[i+1][4]: | |
| 160 l += delta[i+1][4] | |
| 161 i += 1 | |
| 162 result.append(struct.pack(">lll", start, end, len(l)) + l) | |
| 163 i += 1 | |
| 164 return result | |
| 165 | |
| 166 # apply the changes collected during the bisect loop to our addlist | |
| 167 def addlistdelta(addlist, delta): | |
| 168 # apply the deltas to the addlist. start from the bottom up | |
| 169 # so changes to the offsets don't mess things up. | |
| 170 i = len(delta) | |
| 171 while i > 0: | |
| 172 i -= 1 | |
| 173 start = delta[i][0] | |
| 174 end = delta[i][1] | |
| 175 if delta[i][4]: | |
| 176 addlist[start:end] = [delta[i][4]] | |
| 177 else: | |
| 178 del addlist[start:end] | |
| 179 return addlist | |
| 180 | |
| 181 # calculate the byte offset of the start of each line in the | |
| 182 # manifest | |
| 183 def calcoffsets(addlist): | |
| 184 offsets = [0] * (len(addlist) + 1) | |
| 185 offset = 0 | |
| 186 i = 0 | |
| 187 while i < len(addlist): | |
| 188 offsets[i] = offset | |
| 189 offset += len(addlist[i]) | |
| 190 i += 1 | |
| 191 offsets[i] = offset | |
| 192 return offsets | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
193 |
| 644 | 194 # if we're using the listcache, make sure it is valid and |
| 195 # parented by the same node we're diffing against | |
| 741 | 196 if not changed or not self.listcache or not p1 or \ |
| 197 self.mapcache[0] != p1: | |
| 644 | 198 files = map.keys() |
| 199 files.sort() | |
| 200 | |
| 201 self.addlist = ["%s\000%s%s\n" % | |
| 202 (f, hex(map[f]), flags[f] and "x" or '') | |
| 203 for f in files] | |
| 204 cachedelta = None | |
| 205 else: | |
| 206 addlist = self.listcache[1] | |
| 207 | |
| 208 # find the starting offset for each line in the add list | |
| 209 offsets = calcoffsets(addlist) | |
| 210 | |
| 211 # combine the changed lists into one list for sorting | |
| 212 work = [[x, 0] for x in changed[0]] | |
| 213 work[len(work):] = [[x, 1] for x in changed[1]] | |
| 214 work.sort() | |
| 215 | |
| 216 delta = [] | |
| 217 bs = 0 | |
| 218 | |
| 219 for w in work: | |
| 220 f = w[0] | |
| 741 | 221 # bs will either be the index of the item or the insert point |
| 644 | 222 bs = bisect.bisect(addlist, f, bs) |
| 223 if bs < len(addlist): | |
| 224 fn = addlist[bs][:addlist[bs].index('\0')] | |
| 225 else: | |
| 226 fn = None | |
| 227 if w[1] == 0: | |
| 741 | 228 l = "%s\000%s%s\n" % (f, hex(map[f]), |
| 229 flags[f] and "x" or '') | |
| 644 | 230 else: |
| 231 l = None | |
| 232 start = bs | |
| 233 if fn != f: | |
| 234 # item not found, insert a new one | |
| 659 | 235 end = bs |
| 644 | 236 if w[1] == 1: |
|
713
7c385bd5f993
Added missing newline after two error messages.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
705
diff
changeset
|
237 sys.stderr.write("failed to remove %s from manifest\n" |
|
7c385bd5f993
Added missing newline after two error messages.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
705
diff
changeset
|
238 % f) |
| 644 | 239 sys.exit(1) |
| 240 else: | |
| 241 # item is found, replace/delete the existing line | |
| 242 end = bs + 1 | |
| 243 delta.append([start, end, offsets[start], offsets[end], l]) | |
| 244 | |
| 245 self.addlist = addlistdelta(addlist, delta) | |
| 246 if self.mapcache[0] == self.tip(): | |
| 247 cachedelta = "".join(gendelta(delta)) | |
| 248 else: | |
| 249 cachedelta = None | |
| 250 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
251 text = "".join(self.addlist) |
| 644 | 252 if cachedelta and mdiff.patch(self.listcache[0], cachedelta) != text: |
|
713
7c385bd5f993
Added missing newline after two error messages.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
705
diff
changeset
|
253 sys.stderr.write("manifest delta failure\n") |
| 644 | 254 sys.exit(1) |
| 255 n = self.addrevision(text, transaction, link, p1, p2, cachedelta) | |
| 302 | 256 self.mapcache = (n, map, flags) |
|
25
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
257 self.listcache = (text, self.addlist) |
| 140 | 258 self.addlist = None |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
259 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
260 return n |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
261 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
262 class changelog(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
263 def __init__(self, opener): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
264 revlog.__init__(self, opener, "00changelog.i", "00changelog.d") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
265 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
266 def extract(self, text): |
| 37 | 267 if not text: |
| 40 | 268 return (nullid, "", "0", [], "") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
269 last = text.index("\n\n") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
270 desc = text[last + 2:] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
271 l = text[:last].splitlines() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
272 manifest = bin(l[0]) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
273 user = l[1] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
274 date = l[2] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
275 files = l[3:] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
276 return (manifest, user, date, files, desc) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
277 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
278 def read(self, node): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
279 return self.extract(self.revision(node)) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
280 |
| 203 | 281 def add(self, manifest, list, desc, transaction, p1=None, p2=None, |
| 282 user=None, date=None): | |
| 971 | 283 if not date: |
|
968
4a9a753e8232
[PATCH] Take DST into account
Samuel Tardieu <sam@rfc1149.net>
parents:
961
diff
changeset
|
284 if time.daylight: offset = time.altzone |
|
4a9a753e8232
[PATCH] Take DST into account
Samuel Tardieu <sam@rfc1149.net>
parents:
961
diff
changeset
|
285 else: offset = time.timezone |
|
4a9a753e8232
[PATCH] Take DST into account
Samuel Tardieu <sam@rfc1149.net>
parents:
961
diff
changeset
|
286 date = "%d %d" % (time.time(), offset) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
287 list.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
288 l = [hex(manifest), user, date] + list + ["", desc] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
289 text = "\n".join(l) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
290 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
|
291 |
| 220 | 292 class dirstate: |
| 244 | 293 def __init__(self, opener, ui, root): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
294 self.opener = opener |
| 244 | 295 self.root = root |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
296 self.dirty = 0 |
| 20 | 297 self.ui = ui |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
298 self.map = None |
| 227 | 299 self.pl = None |
| 363 | 300 self.copies = {} |
| 723 | 301 self.ignorefunc = None |
| 302 | |
| 303 def wjoin(self, f): | |
| 304 return os.path.join(self.root, f) | |
| 305 | |
|
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
306 def getcwd(self): |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
307 cwd = os.getcwd() |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
308 if cwd == self.root: return '' |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
309 return cwd[len(self.root) + 1:] |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
310 |
| 723 | 311 def ignore(self, f): |
| 312 if not self.ignorefunc: | |
| 313 bigpat = [] | |
| 314 try: | |
| 315 l = file(self.wjoin(".hgignore")) | |
| 316 for pat in l: | |
|
911
d46af8e6b858
Fix .hgignore parsing if last line has no EOL, ignore trailing white space.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
903
diff
changeset
|
317 p = pat.rstrip() |
|
d46af8e6b858
Fix .hgignore parsing if last line has no EOL, ignore trailing white space.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
903
diff
changeset
|
318 if p: |
| 723 | 319 try: |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
320 re.compile(p) |
| 723 | 321 except: |
| 322 self.ui.warn("ignoring invalid ignore" | |
| 323 + " regular expression '%s'\n" % p) | |
| 324 else: | |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
325 bigpat.append(p) |
| 723 | 326 except IOError: pass |
| 327 | |
|
735
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
328 if bigpat: |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
329 s = "(?:%s)" % (")|(?:".join(bigpat)) |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
330 r = re.compile(s) |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
331 self.ignorefunc = r.search |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
332 else: |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
333 self.ignorefunc = util.never |
| 723 | 334 |
| 335 return self.ignorefunc(f) | |
| 220 | 336 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
337 def __del__(self): |
| 220 | 338 if self.dirty: |
| 339 self.write() | |
| 340 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
341 def __getitem__(self, key): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
342 try: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
343 return self.map[key] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
344 except TypeError: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
345 self.read() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
346 return self[key] |
| 220 | 347 |
| 348 def __contains__(self, key): | |
| 349 if not self.map: self.read() | |
| 350 return key in self.map | |
| 351 | |
| 227 | 352 def parents(self): |
| 353 if not self.pl: | |
| 354 self.read() | |
| 355 return self.pl | |
| 356 | |
| 723 | 357 def markdirty(self): |
| 358 if not self.dirty: | |
| 359 self.dirty = 1 | |
| 360 | |
| 227 | 361 def setparents(self, p1, p2 = nullid): |
| 723 | 362 self.markdirty() |
| 227 | 363 self.pl = p1, p2 |
| 364 | |
| 220 | 365 def state(self, key): |
| 366 try: | |
| 367 return self[key][0] | |
| 368 except KeyError: | |
| 369 return "?" | |
| 370 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
371 def read(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
372 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
|
373 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
374 self.map = {} |
| 227 | 375 self.pl = [nullid, nullid] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
376 try: |
| 220 | 377 st = self.opener("dirstate").read() |
| 311 | 378 if not st: return |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
379 except: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
380 |
| 227 | 381 self.pl = [st[:20], st[20: 40]] |
| 382 | |
| 383 pos = 40 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
384 while pos < len(st): |
| 220 | 385 e = struct.unpack(">cllll", st[pos:pos+17]) |
| 386 l = e[4] | |
| 387 pos += 17 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
388 f = st[pos:pos + l] |
| 515 | 389 if '\0' in f: |
| 363 | 390 f, c = f.split('\0') |
| 391 self.copies[f] = c | |
| 220 | 392 self.map[f] = e[:4] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
393 pos += l |
| 363 | 394 |
| 395 def copy(self, source, dest): | |
| 396 self.read() | |
| 723 | 397 self.markdirty() |
| 363 | 398 self.copies[dest] = source |
| 399 | |
| 400 def copied(self, file): | |
| 401 return self.copies.get(file, None) | |
| 515 | 402 |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
403 def update(self, files, state, **kw): |
| 220 | 404 ''' current states: |
| 405 n normal | |
| 231 | 406 m needs merging |
| 220 | 407 r marked for removal |
| 408 a marked for addition''' | |
| 409 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
410 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
411 self.read() |
| 723 | 412 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
413 for f in files: |
| 220 | 414 if state == "r": |
| 415 self.map[f] = ('r', 0, 0, 0) | |
| 416 else: | |
| 253 | 417 s = os.stat(os.path.join(self.root, f)) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
418 st_size = kw.get('st_size', s.st_size) |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
419 st_mtime = kw.get('st_mtime', s.st_mtime) |
|
865
2d2fee33ec68
Cleanup after previous changes:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
863
diff
changeset
|
420 self.map[f] = (state, s.st_mode, st_size, st_mtime) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
421 |
| 220 | 422 def forget(self, files): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
423 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
424 self.read() |
| 723 | 425 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
426 for f in files: |
| 20 | 427 try: |
| 428 del self.map[f] | |
| 429 except KeyError: | |
| 220 | 430 self.ui.warn("not in dirstate: %s!\n" % f) |
| 20 | 431 pass |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
432 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
433 def clear(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
434 self.map = {} |
| 723 | 435 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
436 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
437 def write(self): |
| 220 | 438 st = self.opener("dirstate", "w") |
| 227 | 439 st.write("".join(self.pl)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
440 for f, e in self.map.items(): |
| 363 | 441 c = self.copied(f) |
| 442 if c: | |
| 443 f = f + "\0" + c | |
| 220 | 444 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
|
445 st.write(e + f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
446 self.dirty = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
447 |
| 879 | 448 def filterfiles(self, files): |
| 449 ret = {} | |
| 450 unknown = [] | |
| 451 | |
| 452 for x in files: | |
| 453 if x is '.': | |
| 454 return self.map.copy() | |
| 455 if x not in self.map: | |
| 456 unknown.append(x) | |
| 457 else: | |
| 458 ret[x] = self.map[x] | |
| 919 | 459 |
| 879 | 460 if not unknown: |
| 461 return ret | |
| 462 | |
| 463 b = self.map.keys() | |
| 464 b.sort() | |
| 465 blen = len(b) | |
| 466 | |
| 467 for x in unknown: | |
| 468 bs = bisect.bisect(b, x) | |
| 919 | 469 if bs != 0 and b[bs-1] == x: |
| 879 | 470 ret[x] = self.map[x] |
| 471 continue | |
| 472 while bs < blen: | |
| 473 s = b[bs] | |
| 474 if len(s) > len(x) and s.startswith(x) and s[len(x)] == '/': | |
| 475 ret[s] = self.map[s] | |
| 476 else: | |
| 477 break | |
| 478 bs += 1 | |
| 479 return ret | |
| 480 | |
| 481 def walk(self, files = None, match = util.always, dc=None): | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
482 self.read() |
| 879 | 483 |
| 723 | 484 # walk all files by default |
| 879 | 485 if not files: |
| 486 files = [self.root] | |
| 487 if not dc: | |
| 488 dc = self.map.copy() | |
| 489 elif not dc: | |
| 490 dc = self.filterfiles(files) | |
| 919 | 491 |
|
821
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
492 known = {'.hg': 1} |
|
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
493 def seen(fn): |
|
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
494 if fn in known: return True |
|
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
495 known[fn] = 1 |
| 723 | 496 def traverse(): |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
497 for ff in util.unique(files): |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
498 f = os.path.join(self.root, ff) |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
499 try: |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
500 st = os.stat(f) |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
501 except OSError, inst: |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
502 if ff not in dc: self.ui.warn('%s: %s\n' % ( |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
503 util.pathto(self.getcwd(), ff), |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
504 inst.strerror)) |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
505 continue |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
506 if stat.S_ISDIR(st.st_mode): |
| 536 | 507 for dir, subdirs, fl in os.walk(f): |
| 508 d = dir[len(self.root) + 1:] | |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
509 nd = util.normpath(d) |
|
892
f481c9b6786e
Fix bug involving "hg debugwalk -Ipattern" from repository root.
Bryan O'Sullivan <bos@serpentine.com>
parents:
886
diff
changeset
|
510 if nd == '.': nd = '' |
|
821
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
511 if seen(nd): |
| 723 | 512 subdirs[:] = [] |
| 513 continue | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
514 for sd in subdirs: |
|
820
89985a1b3427
Clean up walk and changes code to use normalised names properly.
Bryan O'Sullivan <bos@serpentine.com>
parents:
814
diff
changeset
|
515 ds = os.path.join(nd, sd +'/') |
| 723 | 516 if self.ignore(ds) or not match(ds): |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
517 subdirs.remove(sd) |
|
822
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
518 subdirs.sort() |
|
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
519 fl.sort() |
| 536 | 520 for fn in fl: |
| 521 fn = util.pconvert(os.path.join(d, fn)) | |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
522 yield 'f', fn |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
523 elif stat.S_ISREG(st.st_mode): |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
524 yield 'f', ff |
| 536 | 525 else: |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
526 kind = 'unknown' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
527 if stat.S_ISCHR(st.st_mode): kind = 'character device' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
528 elif stat.S_ISBLK(st.st_mode): kind = 'block device' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
529 elif stat.S_ISFIFO(st.st_mode): kind = 'fifo' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
530 elif stat.S_ISLNK(st.st_mode): kind = 'symbolic link' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
531 elif stat.S_ISSOCK(st.st_mode): kind = 'socket' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
532 self.ui.warn('%s: unsupported file type (type is %s)\n' % ( |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
533 util.pathto(self.getcwd(), ff), |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
534 kind)) |
| 536 | 535 |
|
822
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
536 ks = dc.keys() |
|
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
537 ks.sort() |
|
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
538 for k in ks: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
539 yield 'm', k |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
540 |
| 723 | 541 # yield only files that match: all in dirstate, others only if |
| 542 # not in .hgignore | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
543 |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
544 for src, fn in util.unique(traverse()): |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
545 fn = util.normpath(fn) |
|
821
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
546 if seen(fn): continue |
| 879 | 547 if fn not in dc and self.ignore(fn): |
| 723 | 548 continue |
| 549 if match(fn): | |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
550 yield src, fn |
| 723 | 551 |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
552 def changes(self, files=None, match=util.always): |
| 723 | 553 self.read() |
| 879 | 554 if not files: |
| 555 dc = self.map.copy() | |
| 556 else: | |
| 557 dc = self.filterfiles(files) | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
558 lookup, modified, added, unknown = [], [], [], [] |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
559 removed, deleted = [], [] |
| 723 | 560 |
| 879 | 561 for src, fn in self.walk(files, match, dc=dc): |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
562 try: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
563 s = os.stat(os.path.join(self.root, fn)) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
564 except OSError: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
565 continue |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
566 if not stat.S_ISREG(s.st_mode): |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
567 continue |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
568 c = dc.get(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
569 if c: |
| 536 | 570 del dc[fn] |
| 571 if c[0] == 'm': | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
572 modified.append(fn) |
| 536 | 573 elif c[0] == 'a': |
| 574 added.append(fn) | |
| 575 elif c[0] == 'r': | |
| 576 unknown.append(fn) | |
| 577 elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100: | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
578 modified.append(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
579 elif c[3] != s.st_mtime: |
| 536 | 580 lookup.append(fn) |
| 581 else: | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
582 unknown.append(fn) |
| 536 | 583 |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
584 for fn, c in [(fn, c) for fn, c in dc.items() if match(fn)]: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
585 if c[0] == 'r': |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
586 removed.append(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
587 else: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
588 deleted.append(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
589 return (lookup, modified, added, removed + deleted, unknown) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
590 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
591 # used to avoid circular references so destructors work |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
592 def opener(base): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
593 p = base |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
594 def o(path, mode="r"): |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
595 if p.startswith("http://"): |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
596 f = os.path.join(p, urllib.quote(path)) |
| 372 | 597 return httprangereader.httprangereader(f) |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
598 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
599 f = os.path.join(p, path) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
600 |
| 292 | 601 mode += "b" # for that other OS |
| 602 | |
| 603 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
|
604 try: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
605 s = os.stat(f) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
606 except OSError: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
607 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
|
608 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
|
609 os.makedirs(d) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
610 else: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
611 if s.st_nlink > 1: |
| 417 | 612 file(f + ".tmp", "wb").write(file(f, "rb").read()) |
| 421 | 613 util.rename(f+".tmp", f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
614 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
615 return file(f, mode) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
616 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
617 return o |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
618 |
| 499 | 619 class RepoError(Exception): pass |
| 620 | |
| 60 | 621 class localrepository: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
622 def __init__(self, ui, path=None, create=0): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
623 self.remote = 0 |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
624 if path and path.startswith("http://"): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
625 self.remote = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
626 self.path = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
627 else: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
628 if not path: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
629 p = os.getcwd() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
630 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
|
631 oldp = p |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
632 p = os.path.dirname(p) |
| 499 | 633 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
|
634 path = p |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
635 self.path = os.path.join(path, ".hg") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
636 |
| 405 | 637 if not create and not os.path.isdir(self.path): |
| 499 | 638 raise RepoError("repository %s not found" % self.path) |
| 405 | 639 |
|
933
9c43d68ad59f
Fixed --repository option when handling relative path
tksoh@users.sf.net
parents:
926
diff
changeset
|
640 self.root = os.path.abspath(path) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
641 self.ui = ui |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
642 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
643 if create: |
| 515 | 644 os.mkdir(self.path) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
645 os.mkdir(self.join("data")) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
646 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
647 self.opener = opener(self.path) |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
648 self.wopener = opener(self.root) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
649 self.manifest = manifest(self.opener) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
650 self.changelog = changelog(self.opener) |
| 343 | 651 self.tagscache = None |
| 652 self.nodetagscache = None | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
653 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
654 if not self.remote: |
| 244 | 655 self.dirstate = dirstate(self.opener, ui, self.root) |
| 337 | 656 try: |
| 657 self.ui.readconfig(self.opener("hgrc")) | |
| 658 except IOError: pass | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
659 |
| 487 | 660 def hook(self, name, **args): |
| 661 s = self.ui.config("hooks", name) | |
| 662 if s: | |
| 663 self.ui.note("running hook %s: %s\n" % (name, s)) | |
| 664 old = {} | |
| 665 for k, v in args.items(): | |
| 666 k = k.upper() | |
| 667 old[k] = os.environ.get(k, None) | |
| 668 os.environ[k] = v | |
| 669 | |
| 670 r = os.system(s) | |
| 671 | |
| 672 for k, v in old.items(): | |
| 673 if v != None: | |
| 674 os.environ[k] = v | |
| 675 else: | |
| 676 del os.environ[k] | |
| 677 | |
| 678 if r: | |
| 679 self.ui.warn("abort: %s hook failed with status %d!\n" % | |
| 680 (name, r)) | |
| 681 return False | |
| 682 return True | |
| 683 | |
| 343 | 684 def tags(self): |
| 685 '''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
|
686 if not self.tagscache: |
| 343 | 687 self.tagscache = {} |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
688 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
|
689 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
690 bin_n = bin(n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
691 except TypeError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
692 bin_n = '' |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
693 self.tagscache[k.strip()] = bin_n |
| 659 | 694 |
| 67 | 695 try: |
| 254 | 696 # read each head of the tags file, ending with the tip |
| 697 # and add each tag found to the map, with "newer" ones | |
| 698 # taking precedence | |
| 67 | 699 fl = self.file(".hgtags") |
| 254 | 700 h = fl.heads() |
| 701 h.reverse() | |
| 702 for r in h: | |
| 703 for l in fl.revision(r).splitlines(): | |
| 704 if l: | |
|
385
e9e1efd5291c
Fixed problems with extra spaces around tags in .hgtags
Thomas Arendsen Hein <thomas@intevation.de>
parents:
383
diff
changeset
|
705 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
|
706 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
|
707 except KeyError: |
|
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
708 pass |
| 659 | 709 |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
710 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
711 f = self.opener("localtags") |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
712 for l in f: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
713 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
|
714 addtag(self, k, n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
715 except IOError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
716 pass |
| 659 | 717 |
| 343 | 718 self.tagscache['tip'] = self.changelog.tip() |
| 659 | 719 |
| 343 | 720 return self.tagscache |
| 721 | |
| 722 def tagslist(self): | |
| 723 '''return a list of tags ordered by revision''' | |
| 724 l = [] | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
725 for t, n in self.tags().items(): |
| 343 | 726 try: |
| 727 r = self.changelog.rev(n) | |
| 728 except: | |
| 729 r = -2 # sort to the beginning of the list if unknown | |
| 730 l.append((r,t,n)) | |
| 731 l.sort() | |
| 732 return [(t,n) for r,t,n in l] | |
| 733 | |
| 734 def nodetags(self, node): | |
| 735 '''return the tags associated with a node''' | |
| 736 if not self.nodetagscache: | |
| 737 self.nodetagscache = {} | |
| 738 for t,n in self.tags().items(): | |
| 739 self.nodetagscache.setdefault(n,[]).append(t) | |
| 740 return self.nodetagscache.get(node, []) | |
| 741 | |
| 742 def lookup(self, key): | |
| 67 | 743 try: |
| 343 | 744 return self.tags()[key] |
| 67 | 745 except KeyError: |
|
658
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
746 try: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
747 return self.changelog.lookup(key) |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
748 except: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
749 raise RepoError("unknown revision '%s'" % key) |
| 67 | 750 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
751 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
752 if self.remote: return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
753 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
|
754 |
| 926 | 755 def local(self): |
| 756 return not self.remote | |
| 757 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
758 def join(self, f): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
759 return os.path.join(self.path, f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
760 |
| 244 | 761 def wjoin(self, f): |
| 762 return os.path.join(self.root, f) | |
| 763 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
764 def file(self, f): |
| 192 | 765 if f[0] == '/': f = f[1:] |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
766 return filelog(self.opener, f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
767 |
| 627 | 768 def getcwd(self): |
|
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
769 return self.dirstate.getcwd() |
| 627 | 770 |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
771 def wfile(self, f, mode='r'): |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
772 return self.wopener(f, mode) |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
773 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
774 def transaction(self): |
| 251 | 775 # save dirstate for undo |
| 263 | 776 try: |
| 777 ds = self.opener("dirstate").read() | |
| 778 except IOError: | |
| 779 ds = "" | |
| 785 | 780 self.opener("journal.dirstate", "w").write(ds) |
| 515 | 781 |
| 785 | 782 def after(): |
| 783 util.rename(self.join("journal"), self.join("undo")) | |
| 784 util.rename(self.join("journal.dirstate"), | |
| 785 self.join("undo.dirstate")) | |
| 786 | |
| 787 return transaction.transaction(self.ui.warn, self.opener, | |
| 788 self.join("journal"), after) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
789 |
| 210 | 790 def recover(self): |
| 225 | 791 lock = self.lock() |
| 557 | 792 if os.path.exists(self.join("journal")): |
| 501 | 793 self.ui.status("rolling back interrupted transaction\n") |
| 557 | 794 return transaction.rollback(self.opener, self.join("journal")) |
| 210 | 795 else: |
| 796 self.ui.warn("no interrupted transaction available\n") | |
| 797 | |
| 798 def undo(self): | |
| 225 | 799 lock = self.lock() |
| 210 | 800 if os.path.exists(self.join("undo")): |
| 501 | 801 self.ui.status("rolling back last transaction\n") |
| 262 | 802 transaction.rollback(self.opener, self.join("undo")) |
| 251 | 803 self.dirstate = None |
| 421 | 804 util.rename(self.join("undo.dirstate"), self.join("dirstate")) |
| 251 | 805 self.dirstate = dirstate(self.opener, self.ui, self.root) |
| 163 | 806 else: |
| 210 | 807 self.ui.warn("no undo information available\n") |
| 162 | 808 |
| 161 | 809 def lock(self, wait = 1): |
| 810 try: | |
| 811 return lock.lock(self.join("lock"), 0) | |
| 812 except lock.LockHeld, inst: | |
| 813 if wait: | |
| 814 self.ui.warn("waiting for lock held by %s\n" % inst.args[0]) | |
| 815 return lock.lock(self.join("lock"), wait) | |
| 816 raise inst | |
| 817 | |
| 203 | 818 def rawcommit(self, files, text, user, date, p1=None, p2=None): |
| 442 | 819 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
|
820 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
|
821 p2 = p2 or self.dirstate.parents()[1] or nullid |
| 302 | 822 c1 = self.changelog.read(p1) |
| 823 c2 = self.changelog.read(p2) | |
| 824 m1 = self.manifest.read(c1[0]) | |
| 825 mf1 = self.manifest.readflags(c1[0]) | |
| 826 m2 = self.manifest.read(c2[0]) | |
| 827 | |
| 442 | 828 if orig_parent == p1: |
| 829 update_dirstate = 1 | |
| 830 else: | |
| 831 update_dirstate = 0 | |
| 832 | |
| 203 | 833 tr = self.transaction() |
| 302 | 834 mm = m1.copy() |
| 835 mfm = mf1.copy() | |
| 203 | 836 linkrev = self.changelog.count() |
| 837 for f in files: | |
| 838 try: | |
| 302 | 839 t = self.wfile(f).read() |
| 441 | 840 tm = util.is_exec(self.wjoin(f), mfm.get(f, False)) |
| 302 | 841 r = self.file(f) |
| 842 mfm[f] = tm | |
| 990 | 843 |
| 844 fp1 = m1.get(f, nullid) | |
| 845 fp2 = m2.get(f, nullid) | |
| 846 | |
| 847 # is the same revision on two branches of a merge? | |
| 848 if fp2 == fp1: | |
| 849 fp2 = nullid | |
| 850 | |
| 851 if fp2 != nullid: | |
| 852 # is one parent an ancestor of the other? | |
| 853 fpa = r.ancestor(fp1, fp2) | |
| 854 if fpa == fp1: | |
| 855 fp1, fp2 = fp2, nullid | |
| 856 elif fpa == fp2: | |
| 857 fp2 = nullid | |
| 858 | |
| 859 # is the file unmodified from the parent? | |
| 860 if t == r.read(fp1): | |
| 861 # record the proper existing parent in manifest | |
| 862 # no need to add a revision | |
| 863 mm[f] = fp1 | |
| 864 continue | |
| 865 | |
| 866 mm[f] = r.add(t, {}, tr, linkrev, fp1, fp2) | |
| 442 | 867 if update_dirstate: |
| 868 self.dirstate.update([f], "n") | |
| 203 | 869 except IOError: |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
870 try: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
871 del mm[f] |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
872 del mfm[f] |
| 442 | 873 if update_dirstate: |
| 874 self.dirstate.forget([f]) | |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
875 except: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
876 # deleted from p2? |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
877 pass |
| 203 | 878 |
| 302 | 879 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
|
880 user = user or self.ui.username() |
| 302 | 881 n = self.changelog.add(mnode, files, text, tr, p1, p2, user, date) |
| 203 | 882 tr.close() |
| 442 | 883 if update_dirstate: |
| 884 self.dirstate.setparents(n, nullid) | |
| 203 | 885 |
|
813
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
886 def commit(self, files = None, text = "", user = None, date = None, |
|
900
ba8cf1f2210c
Add force option to repo.commit, allowing commits where no files change
mason@suse.com
parents:
898
diff
changeset
|
887 match = util.always, force=False): |
| 220 | 888 commit = [] |
| 889 remove = [] | |
| 890 if files: | |
| 891 for f in files: | |
| 892 s = self.dirstate.state(f) | |
| 244 | 893 if s in 'nmai': |
| 220 | 894 commit.append(f) |
| 895 elif s == 'r': | |
| 896 remove.append(f) | |
| 897 else: | |
| 244 | 898 self.ui.warn("%s not tracked!\n" % f) |
| 220 | 899 else: |
|
813
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
900 (c, a, d, u) = self.changes(match = match) |
| 220 | 901 commit = c + a |
| 902 remove = d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
903 |
| 990 | 904 p1, p2 = self.dirstate.parents() |
| 905 c1 = self.changelog.read(p1) | |
| 906 c2 = self.changelog.read(p2) | |
| 907 m1 = self.manifest.read(c1[0]) | |
| 908 mf1 = self.manifest.readflags(c1[0]) | |
| 909 m2 = self.manifest.read(c2[0]) | |
| 910 | |
| 911 if not commit and not remove and not force and p2 == nullid: | |
| 151 | 912 self.ui.status("nothing changed\n") |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
913 return None |
| 151 | 914 |
| 487 | 915 if not self.hook("precommit"): |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
916 return None |
| 487 | 917 |
| 225 | 918 lock = self.lock() |
| 151 | 919 tr = self.transaction() |
| 920 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
921 # check in files |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
922 new = {} |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
923 linkrev = self.changelog.count() |
| 220 | 924 commit.sort() |
| 925 for f in commit: | |
| 83 | 926 self.ui.note(f + "\n") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
927 try: |
| 441 | 928 mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False)) |
| 418 | 929 t = self.wfile(f).read() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
930 except IOError: |
|
667
31a9aa890016
A number of minor fixes to problems that pychecker found.
mark.williamson@cl.cam.ac.uk
parents:
660
diff
changeset
|
931 self.ui.warn("trouble committing %s!\n" % f) |
| 220 | 932 raise |
| 933 | |
| 363 | 934 meta = {} |
| 935 cp = self.dirstate.copied(f) | |
| 936 if cp: | |
| 937 meta["copy"] = cp | |
| 938 meta["copyrev"] = hex(m1.get(cp, m2.get(cp, nullid))) | |
| 575 | 939 self.ui.debug(" %s: copy %s:%s\n" % (f, cp, meta["copyrev"])) |
| 363 | 940 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
941 r = self.file(f) |
| 229 | 942 fp1 = m1.get(f, nullid) |
| 943 fp2 = m2.get(f, nullid) | |
| 990 | 944 |
| 945 # is the same revision on two branches of a merge? | |
| 946 if fp2 == fp1: | |
| 947 fp2 = nullid | |
| 948 | |
| 949 if fp2 != nullid: | |
| 950 # is one parent an ancestor of the other? | |
| 951 fpa = r.ancestor(fp1, fp2) | |
| 952 if fpa == fp1: | |
| 953 fp1, fp2 = fp2, nullid | |
| 954 elif fpa == fp2: | |
| 955 fp2 = nullid | |
| 956 | |
| 957 # is the file unmodified from the parent? | |
| 958 if not meta and t == r.read(fp1): | |
| 959 # record the proper existing parent in manifest | |
| 960 # no need to add a revision | |
| 961 new[f] = fp1 | |
| 962 continue | |
| 963 | |
| 363 | 964 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
|
965 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
966 # update manifest |
| 229 | 967 m1.update(new) |
|
416
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
968 for f in remove: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
969 if f in m1: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
970 del m1[f] |
| 741 | 971 mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0], |
| 972 (new, remove)) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
973 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
974 # add changeset |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
975 new = new.keys() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
976 new.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
977 |
| 288 | 978 if not text: |
| 979 edittext = "\n" + "HG: manifest hash %s\n" % hex(mn) | |
| 980 edittext += "".join(["HG: changed %s\n" % f for f in new]) | |
| 981 edittext += "".join(["HG: removed %s\n" % f for f in remove]) | |
| 982 edittext = self.ui.edit(edittext) | |
| 983 if not edittext.rstrip(): | |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
984 return None |
| 288 | 985 text = edittext |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
986 |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
987 user = user or self.ui.username() |
| 317 | 988 n = self.changelog.add(mn, new, text, tr, p1, p2, user, date) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
989 tr.close() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
990 |
| 229 | 991 self.dirstate.setparents(n) |
| 220 | 992 self.dirstate.update(new, "n") |
| 993 self.dirstate.forget(remove) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
994 |
|
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
995 if not self.hook("commit", node=hex(n)): |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
996 return None |
|
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
997 return n |
|
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
998 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
999 def walk(self, node = None, files = [], match = util.always): |
|
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
1000 if node: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
1001 for fn in self.manifest.read(self.changelog.read(node)[0]): |
|
820
89985a1b3427
Clean up walk and changes code to use normalised names properly.
Bryan O'Sullivan <bos@serpentine.com>
parents:
814
diff
changeset
|
1002 if match(fn): yield 'm', fn |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
1003 else: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
1004 for src, fn in self.dirstate.walk(files, match): |
|
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
1005 yield src, fn |
| 723 | 1006 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
1007 def changes(self, node1 = None, node2 = None, files = [], |
|
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
1008 match = util.always): |
| 566 | 1009 mf2, u = None, [] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1010 |
| 536 | 1011 def fcmp(fn, mf): |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1012 t1 = self.wfile(fn).read() |
| 29 | 1013 t2 = self.file(fn).revision(mf[fn]) |
| 1014 return cmp(t1, t2) | |
| 1015 | |
| 723 | 1016 def mfmatches(node): |
| 1017 mf = dict(self.manifest.read(node)) | |
| 1018 for fn in mf.keys(): | |
| 1019 if not match(fn): | |
| 1020 del mf[fn] | |
| 1021 return mf | |
| 741 | 1022 |
| 536 | 1023 # are we comparing the working directory? |
| 561 | 1024 if not node2: |
| 723 | 1025 l, c, a, d, u = self.dirstate.changes(files, match) |
| 536 | 1026 |
| 1027 # are we comparing working dir against its parent? | |
| 561 | 1028 if not node1: |
| 536 | 1029 if l: |
| 1030 # do a full compare of any files that might have changed | |
| 1031 change = self.changelog.read(self.dirstate.parents()[0]) | |
| 723 | 1032 mf2 = mfmatches(change[0]) |
| 548 | 1033 for f in l: |
| 561 | 1034 if fcmp(f, mf2): |
| 536 | 1035 c.append(f) |
| 561 | 1036 |
| 1037 for l in c, a, d, u: | |
| 1038 l.sort() | |
| 1039 | |
| 536 | 1040 return (c, a, d, u) |
| 515 | 1041 |
| 536 | 1042 # are we comparing working dir against non-tip? |
| 1043 # generate a pseudo-manifest for the working dir | |
| 561 | 1044 if not node2: |
| 1045 if not mf2: | |
| 536 | 1046 change = self.changelog.read(self.dirstate.parents()[0]) |
| 723 | 1047 mf2 = mfmatches(change[0]) |
| 536 | 1048 for f in a + c + l: |
| 561 | 1049 mf2[f] = "" |
| 536 | 1050 for f in d: |
| 561 | 1051 if f in mf2: del mf2[f] |
| 536 | 1052 else: |
| 561 | 1053 change = self.changelog.read(node2) |
| 723 | 1054 mf2 = mfmatches(change[0]) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1055 |
| 566 | 1056 # flush lists from dirstate before comparing manifests |
| 1057 c, a = [], [] | |
| 1058 | |
| 561 | 1059 change = self.changelog.read(node1) |
| 723 | 1060 mf1 = mfmatches(change[0]) |
| 32 | 1061 |
| 1062 for fn in mf2: | |
| 1063 if mf1.has_key(fn): | |
| 1064 if mf1[fn] != mf2[fn]: | |
| 561 | 1065 if mf2[fn] != "" or fcmp(fn, mf1): |
| 536 | 1066 c.append(fn) |
| 32 | 1067 del mf1[fn] |
| 1068 else: | |
| 536 | 1069 a.append(fn) |
| 515 | 1070 |
| 536 | 1071 d = mf1.keys() |
| 561 | 1072 |
| 1073 for l in c, a, d, u: | |
| 1074 l.sort() | |
| 515 | 1075 |
| 536 | 1076 return (c, a, d, u) |
| 32 | 1077 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1078 def add(self, list): |
| 220 | 1079 for f in list: |
| 244 | 1080 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
|
1081 if not os.path.exists(p): |
| 659 | 1082 self.ui.warn("%s does not exist!\n" % f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
1083 elif not os.path.isfile(p): |
| 741 | 1084 self.ui.warn("%s not added: only files supported currently\n" % f) |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
1085 elif self.dirstate.state(f) in 'an': |
| 220 | 1086 self.ui.warn("%s already tracked!\n" % f) |
| 1087 else: | |
| 1088 self.dirstate.update([f], "a") | |
| 1089 | |
| 1090 def forget(self, list): | |
| 1091 for f in list: | |
| 1092 if self.dirstate.state(f) not in 'ai': | |
| 1093 self.ui.warn("%s not added!\n" % f) | |
| 1094 else: | |
| 1095 self.dirstate.forget([f]) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1096 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1097 def remove(self, list): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1098 for f in list: |
| 244 | 1099 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
|
1100 if os.path.exists(p): |
| 220 | 1101 self.ui.warn("%s still exists!\n" % f) |
| 402 | 1102 elif self.dirstate.state(f) == 'a': |
| 1103 self.ui.warn("%s never committed!\n" % f) | |
|
657
22bc6fb9aefc
dirstate.forget() takes a list
Matt Mackall <mpm@selenic.com>
parents:
656
diff
changeset
|
1104 self.dirstate.forget([f]) |
| 220 | 1105 elif f not in self.dirstate: |
| 1106 self.ui.warn("%s not tracked!\n" % f) | |
| 1107 else: | |
| 1108 self.dirstate.update([f], "r") | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1109 |
| 363 | 1110 def copy(self, source, dest): |
| 1111 p = self.wjoin(dest) | |
| 781 | 1112 if not os.path.exists(p): |
| 363 | 1113 self.ui.warn("%s does not exist!\n" % dest) |
| 781 | 1114 elif not os.path.isfile(p): |
| 659 | 1115 self.ui.warn("copy failed: %s is not a file\n" % dest) |
| 363 | 1116 else: |
| 1117 if self.dirstate.state(dest) == '?': | |
| 1118 self.dirstate.update([dest], "a") | |
| 1119 self.dirstate.copy(source, dest) | |
| 1120 | |
| 222 | 1121 def heads(self): |
| 1122 return self.changelog.heads() | |
| 1123 | |
| 898 | 1124 # branchlookup returns a dict giving a list of branches for |
| 1125 # each head. A branch is defined as the tag of a node or | |
| 1126 # the branch of the node's parents. If a node has multiple | |
| 1127 # branch tags, tags are eliminated if they are visible from other | |
| 1128 # branch tags. | |
| 1129 # | |
| 1130 # So, for this graph: a->b->c->d->e | |
| 1131 # \ / | |
| 1132 # aa -----/ | |
| 919 | 1133 # a has tag 2.6.12 |
| 898 | 1134 # d has tag 2.6.13 |
| 1135 # e would have branch tags for 2.6.12 and 2.6.13. Because the node | |
| 1136 # for 2.6.12 can be reached from the node 2.6.13, that is eliminated | |
| 1137 # from the list. | |
| 1138 # | |
| 1139 # It is possible that more than one head will have the same branch tag. | |
| 1140 # callers need to check the result for multiple heads under the same | |
| 1141 # branch tag if that is a problem for them (ie checkout of a specific | |
| 1142 # branch). | |
| 1143 # | |
| 1144 # passing in a specific branch will limit the depth of the search | |
| 1145 # through the parents. It won't limit the branches returned in the | |
| 1146 # result though. | |
| 1147 def branchlookup(self, heads=None, branch=None): | |
| 1148 if not heads: | |
| 1149 heads = self.heads() | |
| 1150 headt = [ h for h in heads ] | |
| 1151 chlog = self.changelog | |
| 1152 branches = {} | |
| 1153 merges = [] | |
| 1154 seenmerge = {} | |
| 1155 | |
| 1156 # traverse the tree once for each head, recording in the branches | |
| 1157 # dict which tags are visible from this head. The branches | |
| 1158 # dict also records which tags are visible from each tag | |
| 1159 # while we traverse. | |
| 1160 while headt or merges: | |
| 1161 if merges: | |
| 1162 n, found = merges.pop() | |
| 1163 visit = [n] | |
| 1164 else: | |
| 1165 h = headt.pop() | |
| 1166 visit = [h] | |
| 1167 found = [h] | |
| 1168 seen = {} | |
| 1169 while visit: | |
| 1170 n = visit.pop() | |
| 1171 if n in seen: | |
| 1172 continue | |
| 1173 pp = chlog.parents(n) | |
| 1174 tags = self.nodetags(n) | |
| 1175 if tags: | |
| 1176 for x in tags: | |
| 1177 if x == 'tip': | |
| 1178 continue | |
| 1179 for f in found: | |
| 1180 branches.setdefault(f, {})[n] = 1 | |
| 1181 branches.setdefault(n, {})[n] = 1 | |
| 1182 break | |
| 1183 if n not in found: | |
| 1184 found.append(n) | |
| 1185 if branch in tags: | |
| 1186 continue | |
| 1187 seen[n] = 1 | |
| 1188 if pp[1] != nullid and n not in seenmerge: | |
| 1189 merges.append((pp[1], [x for x in found])) | |
| 1190 seenmerge[n] = 1 | |
| 1191 if pp[0] != nullid: | |
| 1192 visit.append(pp[0]) | |
| 1193 # traverse the branches dict, eliminating branch tags from each | |
| 1194 # head that are visible from another branch tag for that head. | |
| 1195 out = {} | |
| 1196 viscache = {} | |
| 1197 for h in heads: | |
| 1198 def visible(node): | |
| 1199 if node in viscache: | |
| 1200 return viscache[node] | |
| 1201 ret = {} | |
| 1202 visit = [node] | |
| 1203 while visit: | |
| 1204 x = visit.pop() | |
| 1205 if x in viscache: | |
| 1206 ret.update(viscache[x]) | |
| 1207 elif x not in ret: | |
| 1208 ret[x] = 1 | |
| 1209 if x in branches: | |
| 1210 visit[len(visit):] = branches[x].keys() | |
| 1211 viscache[node] = ret | |
| 1212 return ret | |
| 1213 if h not in branches: | |
| 1214 continue | |
| 1215 # O(n^2), but somewhat limited. This only searches the | |
| 1216 # tags visible from a specific head, not all the tags in the | |
| 1217 # whole repo. | |
| 1218 for b in branches[h]: | |
| 1219 vis = False | |
| 1220 for bb in branches[h].keys(): | |
| 1221 if b != bb: | |
| 1222 if b in visible(bb): | |
| 1223 vis = True | |
| 1224 break | |
| 1225 if not vis: | |
| 1226 l = out.setdefault(h, []) | |
| 1227 l[len(l):] = self.nodetags(b) | |
| 1228 return out | |
| 1229 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1230 def branches(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1231 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
|
1232 b = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1233 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1234 t = n |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1235 while n: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1236 p = self.changelog.parents(n) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1237 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
|
1238 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
|
1239 break |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1240 n = p[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1241 return b |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1242 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1243 def between(self, pairs): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1244 r = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1245 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1246 for top, bottom in pairs: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1247 n, l, i = top, [], 0 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1248 f = 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1249 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1250 while n != bottom: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1251 p = self.changelog.parents(n)[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1252 if i == f: |
| 575 | 1253 l.append(n) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1254 f = f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1255 n = p |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1256 i += 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1257 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1258 r.append(l) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1259 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1260 return r |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1261 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1262 def newer(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1263 m = {} |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1264 nl = [] |
| 94 | 1265 pm = {} |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1266 cl = self.changelog |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1267 t = l = cl.count() |
| 94 | 1268 |
| 1269 # find the lowest numbered node | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1270 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1271 l = min(l, cl.rev(n)) |
| 94 | 1272 m[n] = 1 |
| 46 | 1273 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1274 for i in xrange(l, t): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1275 n = cl.node(i) |
| 94 | 1276 if n in m: # explicitly listed |
| 1277 pm[n] = 1 | |
| 1278 nl.append(n) | |
| 1279 continue | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1280 for p in cl.parents(n): |
| 94 | 1281 if p in pm: # parent listed |
| 1282 pm[n] = 1 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1283 nl.append(n) |
| 94 | 1284 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1285 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1286 return nl |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1287 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1288 def findincoming(self, remote, base=None, heads=None): |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1289 m = self.changelog.nodemap |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1290 search = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1291 fetch = [] |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1292 seen = {} |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1293 seenbranch = {} |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1294 if base == None: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1295 base = {} |
| 192 | 1296 |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1297 # 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
|
1298 # and start by examining the heads |
| 222 | 1299 self.ui.status("searching for changes\n") |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1300 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1301 if not heads: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1302 heads = remote.heads() |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1303 |
| 222 | 1304 unknown = [] |
| 1305 for h in heads: | |
| 1306 if h not in m: | |
| 1307 unknown.append(h) | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1308 else: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1309 base[h] = 1 |
| 46 | 1310 |
| 222 | 1311 if not unknown: |
| 60 | 1312 return None |
| 324 | 1313 |
| 1314 rep = {} | |
| 1315 reqcnt = 0 | |
| 515 | 1316 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1317 # search through remote branches |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1318 # 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
|
1319 # head, root, first parent, second parent |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1320 # (a branch always has two parents (or none) by definition) |
| 222 | 1321 unknown = remote.branches(unknown) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1322 while unknown: |
| 324 | 1323 r = [] |
| 1324 while unknown: | |
| 1325 n = unknown.pop(0) | |
| 1326 if n[0] in seen: | |
| 1327 continue | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1328 |
| 324 | 1329 self.ui.debug("examining %s:%s\n" % (short(n[0]), short(n[1]))) |
| 1330 if n[0] == nullid: | |
| 1331 break | |
| 328 | 1332 if n in seenbranch: |
| 324 | 1333 self.ui.debug("branch already found\n") |
| 1334 continue | |
| 1335 if n[1] and n[1] in m: # do we know the base? | |
| 1336 self.ui.debug("found incomplete branch %s:%s\n" | |
| 1337 % (short(n[0]), short(n[1]))) | |
| 1338 search.append(n) # schedule branch range for scanning | |
| 328 | 1339 seenbranch[n] = 1 |
| 324 | 1340 else: |
| 1341 if n[1] not in seen and n[1] not in fetch: | |
| 1342 if n[2] in m and n[3] in m: | |
| 1343 self.ui.debug("found new changeset %s\n" % | |
| 1344 short(n[1])) | |
| 1345 fetch.append(n[1]) # earliest unknown | |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1346 base[n[2]] = 1 # latest known |
| 324 | 1347 continue |
| 1348 | |
| 1349 for a in n[2:4]: | |
| 1350 if a not in rep: | |
| 1351 r.append(a) | |
| 1352 rep[a] = 1 | |
| 1353 | |
| 328 | 1354 seen[n[0]] = 1 |
| 1355 | |
| 324 | 1356 if r: |
| 1357 reqcnt += 1 | |
| 1358 self.ui.debug("request %d: %s\n" % | |
| 1359 (reqcnt, " ".join(map(short, r)))) | |
| 1360 for p in range(0, len(r), 10): | |
| 1361 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
|
1362 self.ui.debug("received %s:%s\n" % |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1363 (short(b[0]), short(b[1]))) |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1364 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
|
1365 unknown.append(b) |
| 515 | 1366 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1367 # 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
|
1368 while search: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1369 n = search.pop(0) |
| 324 | 1370 reqcnt += 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1371 l = remote.between([(n[0], n[1])])[0] |
| 328 | 1372 l.append(n[1]) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1373 p = n[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1374 f = 1 |
| 328 | 1375 for i in l: |
| 1376 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
|
1377 if i in m: |
| 85 | 1378 if f <= 2: |
| 83 | 1379 self.ui.debug("found new branch changeset %s\n" % |
| 1380 short(p)) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1381 fetch.append(p) |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1382 base[i] = 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1383 else: |
| 83 | 1384 self.ui.debug("narrowed branch search to %s:%s\n" |
| 1385 % (short(p), short(i))) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1386 search.append((p, i)) |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1387 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1388 p, f = i, f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1389 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1390 # 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
|
1391 for f in fetch: |
|
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1392 if f in m: |
| 499 | 1393 raise RepoError("already have changeset " + short(f[:4])) |
| 83 | 1394 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1395 if base.keys() == [nullid]: |
|
514
874e577e332e
change unrelated repository error to a warning
mpm@selenic.com
parents:
511
diff
changeset
|
1396 self.ui.warn("warning: pulling from an unrelated repository!\n") |
| 511 | 1397 |
| 94 | 1398 self.ui.note("adding new changesets starting at " + |
| 83 | 1399 " ".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
|
1400 |
| 324 | 1401 self.ui.debug("%d total queries\n" % reqcnt) |
| 1402 | |
| 516 | 1403 return fetch |
| 1404 | |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1405 def findoutgoing(self, remote, base=None, heads=None): |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1406 if base == None: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1407 base = {} |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1408 self.findincoming(remote, base, heads) |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1409 |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1410 remain = dict.fromkeys(self.changelog.nodemap) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1411 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1412 # prune everything remote has from the tree |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
1413 del remain[nullid] |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1414 remove = base.keys() |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1415 while remove: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1416 n = remove.pop(0) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1417 if n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1418 del remain[n] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1419 for p in self.changelog.parents(n): |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
1420 remove.append(p) |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1421 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1422 # 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
|
1423 subset = [] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1424 for n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1425 p1, p2 = self.changelog.parents(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1426 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
|
1427 subset.append(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1428 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1429 # 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
|
1430 return subset |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1431 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1432 def pull(self, remote): |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1433 lock = self.lock() |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1434 |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1435 # if we have an empty repo, fetch everything |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1436 if self.changelog.tip() == nullid: |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1437 self.ui.status("requesting all changes\n") |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1438 fetch = [nullid] |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1439 else: |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1440 fetch = self.findincoming(remote) |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1441 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1442 if not fetch: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1443 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
|
1444 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1445 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1446 cg = remote.changegroup(fetch) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1447 return self.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1448 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1449 def push(self, remote, force=False): |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1450 lock = remote.lock() |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1451 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1452 base = {} |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1453 heads = remote.heads() |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1454 inc = self.findincoming(remote, base, heads) |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1455 if not force and inc: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1456 self.ui.warn("abort: unsynced remote changes!\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1457 self.ui.status("(did you forget to sync? use push -f to force)\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1458 return 1 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1459 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1460 update = self.findoutgoing(remote, base) |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1461 if not update: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1462 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
|
1463 return 1 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1464 elif not force: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1465 if len(heads) < len(self.changelog.heads()): |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1466 self.ui.warn("abort: push creates new remote branches!\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1467 self.ui.status("(did you forget to merge?" + |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1468 " use push -f to force)\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1469 return 1 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1470 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1471 cg = self.changegroup(update) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1472 return remote.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1473 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1474 def changegroup(self, basenodes): |
| 222 | 1475 class genread: |
| 1476 def __init__(self, generator): | |
| 1477 self.g = generator | |
| 1478 self.buf = "" | |
|
903
71be6dd282d1
Allow the changegroup generator to completely load the buffer.
mason@suse.com
parents:
901
diff
changeset
|
1479 def fillbuf(self): |
|
71be6dd282d1
Allow the changegroup generator to completely load the buffer.
mason@suse.com
parents:
901
diff
changeset
|
1480 self.buf += "".join(self.g) |
|
71be6dd282d1
Allow the changegroup generator to completely load the buffer.
mason@suse.com
parents:
901
diff
changeset
|
1481 |
| 222 | 1482 def read(self, l): |
| 1483 while l > len(self.buf): | |
| 1484 try: | |
| 1485 self.buf += self.g.next() | |
| 1486 except StopIteration: | |
| 1487 break | |
| 1488 d, self.buf = self.buf[:l], self.buf[l:] | |
| 1489 return d | |
| 515 | 1490 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1491 def gengroup(): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1492 nodes = self.newer(basenodes) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1493 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1494 # construct the link map |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1495 linkmap = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1496 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1497 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
|
1498 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1499 # 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
|
1500 changed = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1501 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1502 c = self.changelog.read(n) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1503 for f in c[3]: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1504 changed[f] = 1 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1505 changed = changed.keys() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1506 changed.sort() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1507 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1508 # 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
|
1509 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
|
1510 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1511 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
|
1512 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
|
1513 for f in changed: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1514 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
|
1515 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
|
1516 for y in g: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1517 yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1518 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1519 yield struct.pack(">l", 0) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1520 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1521 return genread(gengroup()) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1522 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1523 def addchangegroup(self, source): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1524 |
| 222 | 1525 def getchunk(): |
| 1526 d = source.read(4) | |
| 1527 if not d: return "" | |
| 1528 l = struct.unpack(">l", d)[0] | |
| 1529 if l <= 4: return "" | |
| 1530 return source.read(l - 4) | |
| 1531 | |
| 1532 def getgroup(): | |
| 1533 while 1: | |
| 1534 c = getchunk() | |
| 1535 if not c: break | |
| 1536 yield c | |
| 1537 | |
| 1538 def csmap(x): | |
| 1539 self.ui.debug("add changeset %s\n" % short(x)) | |
| 1540 return self.changelog.count() | |
| 1541 | |
| 1542 def revmap(x): | |
| 1543 return self.changelog.rev(x) | |
| 1544 | |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1545 if not source: return |
| 222 | 1546 changesets = files = revisions = 0 |
| 225 | 1547 |
| 222 | 1548 tr = self.transaction() |
| 1549 | |
| 1550 # pull off the changeset group | |
| 1551 self.ui.status("adding changesets\n") | |
| 1552 co = self.changelog.tip() | |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
223
diff
changeset
|
1553 cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique |
| 222 | 1554 changesets = self.changelog.rev(cn) - self.changelog.rev(co) |
| 1555 | |
| 1556 # pull off the manifest group | |
| 1557 self.ui.status("adding manifests\n") | |
| 1558 mm = self.manifest.tip() | |
| 1559 mo = self.manifest.addgroup(getgroup(), revmap, tr) | |
| 1560 | |
| 1561 # process the files | |
| 772 | 1562 self.ui.status("adding file changes\n") |
| 222 | 1563 while 1: |
| 1564 f = getchunk() | |
| 1565 if not f: break | |
| 1566 self.ui.debug("adding %s revisions\n" % f) | |
| 1567 fl = self.file(f) | |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1568 o = fl.count() |
| 222 | 1569 n = fl.addgroup(getgroup(), revmap, tr) |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1570 revisions += fl.count() - o |
| 222 | 1571 files += 1 |
| 1572 | |
| 772 | 1573 self.ui.status(("added %d changesets" + |
| 1574 " with %d changes to %d files\n") | |
| 1575 % (changesets, revisions, files)) | |
| 222 | 1576 |
| 1577 tr.close() | |
| 780 | 1578 |
| 1579 if not self.hook("changegroup"): | |
| 1580 return 1 | |
| 1581 | |
| 222 | 1582 return |
| 1583 | |
| 588 | 1584 def update(self, node, allow=False, force=False, choose=None, |
| 1585 moddirstate=True): | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1586 pl = self.dirstate.parents() |
| 275 | 1587 if not force and pl[1] != nullid: |
| 254 | 1588 self.ui.warn("aborting: outstanding uncommitted merges\n") |
| 690 | 1589 return 1 |
| 46 | 1590 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1591 p1, p2 = pl[0], node |
| 305 | 1592 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
|
1593 m1n = self.changelog.read(p1)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1594 m2n = self.changelog.read(p2)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1595 man = self.manifest.ancestor(m1n, m2n) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1596 m1 = self.manifest.read(m1n) |
| 276 | 1597 mf1 = self.manifest.readflags(m1n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1598 m2 = self.manifest.read(m2n) |
| 276 | 1599 mf2 = self.manifest.readflags(m2n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1600 ma = self.manifest.read(man) |
| 412 | 1601 mfa = self.manifest.readflags(man) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1602 |
| 723 | 1603 (c, a, d, u) = self.changes() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1604 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1605 # 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
|
1606 # from p1 to p2? |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1607 linear_path = (pa == p1 or pa == p2) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1608 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1609 # 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
|
1610 # we care about merging |
| 254 | 1611 self.ui.note("resolving manifests\n") |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1612 self.ui.debug(" force %s allow %s moddirstate %s linear %s\n" % |
|
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1613 (force, allow, moddirstate, linear_path)) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1614 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
|
1615 (short(man), short(m1n), short(m2n))) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1616 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1617 merge = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1618 get = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1619 remove = [] |
| 305 | 1620 mark = {} |
| 46 | 1621 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1622 # construct a working dir manifest |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1623 mw = m1.copy() |
| 276 | 1624 mfw = mf1.copy() |
| 576 | 1625 umap = dict.fromkeys(u) |
| 1626 | |
| 254 | 1627 for f in a + c + u: |
| 1628 mw[f] = "" | |
| 441 | 1629 mfw[f] = util.is_exec(self.wjoin(f), mfw.get(f, False)) |
| 576 | 1630 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1631 for f in d: |
| 254 | 1632 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
|
1633 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1634 # 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
|
1635 # 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
|
1636 # 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
|
1637 # 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
|
1638 # longer in the manifest. |
| 588 | 1639 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
|
1640 self.dirstate.forget((f,)) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1641 |
| 576 | 1642 # Compare manifests |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1643 for f, n in mw.iteritems(): |
| 588 | 1644 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
|
1645 if f in m2: |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1646 s = 0 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1647 |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1648 # is the wfile new since m1, and match m2? |
| 428 | 1649 if f not in m1: |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1650 t1 = self.wfile(f).read() |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1651 t2 = self.file(f).revision(m2[f]) |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1652 if cmp(t1, t2) == 0: |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1653 mark[f] = 1 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1654 n = m2[f] |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1655 del t1, t2 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1656 |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1657 # are files different? |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1658 if n != m2[f]: |
| 254 | 1659 a = ma.get(f, nullid) |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1660 # are both different from the ancestor? |
| 254 | 1661 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
|
1662 self.ui.debug(" %s versions differ, resolve\n" % f) |
| 276 | 1663 # merge executable bits |
| 1664 # "if we changed or they changed, change in merge" | |
| 1665 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] | |
| 1666 mode = ((a^b) | (a^c)) ^ a | |
| 1667 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
|
1668 s = 1 |
| 305 | 1669 # are we clobbering? |
| 1670 # is remote's version newer? | |
| 1671 # or are we going back in time? | |
| 1672 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
|
1673 self.ui.debug(" remote %s is newer, get\n" % f) |
| 254 | 1674 get[f] = m2[f] |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1675 s = 1 |
| 305 | 1676 else: |
| 1677 mark[f] = 1 | |
| 576 | 1678 elif f in umap: |
| 1679 # this unknown file is the same as the checkout | |
| 1680 get[f] = m2[f] | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1681 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1682 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
|
1683 if force: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1684 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1685 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
|
1686 else: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1687 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
|
1688 mode = ((a^b) | (a^c)) ^ a |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1689 if mode != b: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1690 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1691 util.set_exec(self.wjoin(f), mode) |
| 305 | 1692 mark[f] = 1 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1693 del m2[f] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1694 elif f in ma: |
| 616 | 1695 if n != ma[f]: |
| 1696 r = "d" | |
| 1697 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
|
1698 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
|
1699 (" 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
|
1700 "(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
|
1701 if r == "d": |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1702 remove.append(f) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1703 else: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1704 self.ui.debug("other deleted %s\n" % f) |
| 254 | 1705 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
|
1706 else: |
| 254 | 1707 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
|
1708 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
|
1709 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
|
1710 remove.append(f) |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1711 else: |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1712 self.ui.debug("local created %s, keeping\n" % f) |
| 254 | 1713 else: |
| 1714 self.ui.debug("working dir created %s, keeping\n" % f) | |
| 46 | 1715 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1716 for f, n in m2.iteritems(): |
| 588 | 1717 if choose and not choose(f): continue |
| 256 | 1718 if f[0] == "/": continue |
| 616 | 1719 if f in ma and n != ma[f]: |
| 1720 r = "k" | |
| 1721 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
|
1722 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
|
1723 ("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
|
1724 "(k)eep or (d)elete?", "[kd]", "k") |
| 616 | 1725 if r == "k": get[f] = n |
| 1726 elif f not in ma: | |
| 254 | 1727 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
|
1728 get[f] = n |
| 616 | 1729 else: |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1730 if force or p2 == pa: # going backwards? |
|
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1731 self.ui.debug("local deleted %s, recreating\n" % f) |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1732 get[f] = n |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1733 else: |
|
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1734 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
|
1735 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1736 del mw, m1, m2, ma |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1737 |
| 275 | 1738 if force: |
| 1739 for f in merge: | |
| 1740 get[f] = merge[f][1] | |
| 1741 merge = {} | |
| 1742 | |
| 690 | 1743 if linear_path or force: |
| 254 | 1744 # we don't need to do any magic, just jump to the new rev |
| 1745 mode = 'n' | |
| 1746 p1, p2 = p2, nullid | |
| 1747 else: | |
| 275 | 1748 if not allow: |
| 305 | 1749 self.ui.status("this update spans a branch" + |
| 1750 " affecting the following files:\n") | |
| 1751 fl = merge.keys() + get.keys() | |
| 1752 fl.sort() | |
| 1753 for f in fl: | |
| 1754 cf = "" | |
| 1755 if f in merge: cf = " (resolve)" | |
| 1756 self.ui.status(" %s%s\n" % (f, cf)) | |
| 1757 self.ui.warn("aborting update spanning branches!\n") | |
| 788 | 1758 self.ui.status("(use update -m to merge across branches" + |
| 1759 " or -C to lose changes)\n") | |
| 275 | 1760 return 1 |
| 254 | 1761 mode = 'm' |
| 1762 | |
| 588 | 1763 if moddirstate: |
| 1764 self.dirstate.setparents(p1, p2) | |
|
191
d7e859cf2f1b
merge: add count of new manifests, files, and revisions
mpm@selenic.com
parents:
190
diff
changeset
|
1765 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1766 # 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
|
1767 files = get.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1768 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1769 for f in files: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1770 if f[0] == "/": continue |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1771 self.ui.note("getting %s\n" % f) |
| 276 | 1772 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
|
1773 try: |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1774 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
|
1775 except IOError: |
|
297
0dbcf3c9ff20
Fixed usage of removed variable 'wp'.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
292
diff
changeset
|
1776 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
|
1777 self.wfile(f, "w").write(t) |
| 441 | 1778 util.set_exec(self.wjoin(f), mf2[f]) |
| 588 | 1779 if moddirstate: |
| 990 | 1780 self.dirstate.update([f], 'n') |
| 46 | 1781 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1782 # merge the tricky bits |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1783 files = merge.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1784 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1785 for f in files: |
| 256 | 1786 self.ui.status("merging %s\n" % f) |
| 276 | 1787 m, o, flag = merge[f] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1788 self.merge3(f, m, o) |
| 441 | 1789 util.set_exec(self.wjoin(f), flag) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1790 if moddirstate: |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1791 if mode == 'm': |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1792 # only update dirstate on branch merge, otherwise we |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1793 # could mark files with changes as unchanged |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1794 self.dirstate.update([f], mode) |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1795 elif p2 == nullid: |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1796 # update dirstate from parent1's manifest |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1797 m1n = self.changelog.read(p1)[0] |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1798 m1 = self.manifest.read(m1n) |
|
865
2d2fee33ec68
Cleanup after previous changes:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
863
diff
changeset
|
1799 f_len = len(self.file(f).read(m1[f])) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1800 self.dirstate.update([f], mode, st_size=f_len, st_mtime=0) |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1801 else: |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1802 self.ui.warn("Second parent without branch merge!?\n" |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1803 "Dirstate for file %s may be wrong.\n" % f) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1804 |
| 681 | 1805 remove.sort() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1806 for f in remove: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1807 self.ui.note("removing %s\n" % f) |
| 690 | 1808 try: |
|
934
ff484cc157d6
Fix path handling for deleting files on merge
mpm@selenic.com
parents:
933
diff
changeset
|
1809 os.unlink(self.wjoin(f)) |
| 690 | 1810 except OSError, inst: |
| 1811 self.ui.warn("update failed to remove %s: %s!\n" % (f, inst)) | |
| 578 | 1812 # try removing directories that might now be empty |
|
934
ff484cc157d6
Fix path handling for deleting files on merge
mpm@selenic.com
parents:
933
diff
changeset
|
1813 try: os.removedirs(os.path.dirname(self.wjoin(f))) |
| 578 | 1814 except: pass |
| 588 | 1815 if moddirstate: |
| 1816 if mode == 'n': | |
| 1817 self.dirstate.forget(remove) | |
| 1818 else: | |
| 1819 self.dirstate.update(remove, 'r') | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1820 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1821 def merge3(self, fn, my, other): |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1822 """perform a 3-way merge in the working directory""" |
| 249 | 1823 |
| 96 | 1824 def temp(prefix, node): |
| 1825 pre = "%s~%s." % (os.path.basename(fn), prefix) | |
| 1826 (fd, name) = tempfile.mkstemp("", pre) | |
| 417 | 1827 f = os.fdopen(fd, "wb") |
| 96 | 1828 f.write(fl.revision(node)) |
| 1829 f.close() | |
| 1830 return name | |
| 1831 | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1832 fl = self.file(fn) |
| 96 | 1833 base = fl.ancestor(my, other) |
| 244 | 1834 a = self.wjoin(fn) |
| 346 | 1835 b = temp("base", base) |
| 1836 c = temp("other", other) | |
| 96 | 1837 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1838 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
|
1839 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
|
1840 (fn, short(other), short(base))) |
| 96 | 1841 |
|
703
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1842 cmd = (os.environ.get("HGMERGE") or self.ui.config("ui", "merge") |
|
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1843 or "hgmerge") |
| 240 | 1844 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
|
1845 if r: |
| 275 | 1846 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
|
1847 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1848 os.unlink(b) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1849 os.unlink(c) |
| 96 | 1850 |
| 247 | 1851 def verify(self): |
| 1852 filelinkrevs = {} | |
| 1853 filenodes = {} | |
| 1854 changesets = revisions = files = 0 | |
| 1855 errors = 0 | |
| 1856 | |
| 302 | 1857 seen = {} |
| 247 | 1858 self.ui.status("checking changesets\n") |
| 1859 for i in range(self.changelog.count()): | |
| 1860 changesets += 1 | |
| 1861 n = self.changelog.node(i) | |
| 302 | 1862 if n in seen: |
| 1863 self.ui.warn("duplicate changeset at revision %d\n" % i) | |
| 1864 errors += 1 | |
| 1865 seen[n] = 1 | |
| 515 | 1866 |
| 247 | 1867 for p in self.changelog.parents(n): |
| 1868 if p not in self.changelog.nodemap: | |
| 1869 self.ui.warn("changeset %s has unknown parent %s\n" % | |
| 1870 (short(n), short(p))) | |
| 1871 errors += 1 | |
| 1872 try: | |
| 1873 changes = self.changelog.read(n) | |
| 1874 except Exception, inst: | |
| 1875 self.ui.warn("unpacking changeset %s: %s\n" % (short(n), inst)) | |
| 1876 errors += 1 | |
| 1877 | |
| 1878 for f in changes[3]: | |
| 1879 filelinkrevs.setdefault(f, []).append(i) | |
| 1880 | |
| 302 | 1881 seen = {} |
| 247 | 1882 self.ui.status("checking manifests\n") |
| 1883 for i in range(self.manifest.count()): | |
| 1884 n = self.manifest.node(i) | |
| 302 | 1885 if n in seen: |
| 1886 self.ui.warn("duplicate manifest at revision %d\n" % i) | |
| 1887 errors += 1 | |
| 1888 seen[n] = 1 | |
| 515 | 1889 |
| 247 | 1890 for p in self.manifest.parents(n): |
| 1891 if p not in self.manifest.nodemap: | |
| 1892 self.ui.warn("manifest %s has unknown parent %s\n" % | |
| 1893 (short(n), short(p))) | |
| 1894 errors += 1 | |
| 1895 | |
| 1896 try: | |
| 1897 delta = mdiff.patchtext(self.manifest.delta(n)) | |
| 1898 except KeyboardInterrupt: | |
| 582 | 1899 self.ui.warn("aborted") |
| 247 | 1900 sys.exit(0) |
| 1901 except Exception, inst: | |
| 1902 self.ui.warn("unpacking manifest %s: %s\n" | |
| 1903 % (short(n), inst)) | |
| 1904 errors += 1 | |
| 1905 | |
| 1906 ff = [ l.split('\0') for l in delta.splitlines() ] | |
| 1907 for f, fn in ff: | |
| 284 | 1908 filenodes.setdefault(f, {})[bin(fn[:40])] = 1 |
| 247 | 1909 |
| 1910 self.ui.status("crosschecking files in changesets and manifests\n") | |
| 1911 for f in filenodes: | |
| 1912 if f not in filelinkrevs: | |
| 1913 self.ui.warn("file %s in manifest but not in changesets\n" % f) | |
| 1914 errors += 1 | |
| 1915 | |
| 1916 for f in filelinkrevs: | |
| 1917 if f not in filenodes: | |
| 1918 self.ui.warn("file %s in changeset but not in manifest\n" % f) | |
| 1919 errors += 1 | |
| 1920 | |
| 1921 self.ui.status("checking files\n") | |
| 1922 ff = filenodes.keys() | |
| 1923 ff.sort() | |
| 1924 for f in ff: | |
| 1925 if f == "/dev/null": continue | |
| 1926 files += 1 | |
| 1927 fl = self.file(f) | |
| 1928 nodes = { nullid: 1 } | |
| 302 | 1929 seen = {} |
| 247 | 1930 for i in range(fl.count()): |
| 1931 revisions += 1 | |
| 1932 n = fl.node(i) | |
| 1933 | |
| 302 | 1934 if n in seen: |
| 1935 self.ui.warn("%s: duplicate revision %d\n" % (f, i)) | |
| 1936 errors += 1 | |
| 1937 | |
| 247 | 1938 if n not in filenodes[f]: |
| 1939 self.ui.warn("%s: %d:%s not in manifests\n" | |
| 1940 % (f, i, short(n))) | |
| 1941 errors += 1 | |
| 1942 else: | |
| 1943 del filenodes[f][n] | |
| 1944 | |
| 1945 flr = fl.linkrev(n) | |
| 1946 if flr not in filelinkrevs[f]: | |
| 1947 self.ui.warn("%s:%s points to unexpected changeset %d\n" | |
| 1948 % (f, short(n), fl.linkrev(n))) | |
| 1949 errors += 1 | |
| 1950 else: | |
| 1951 filelinkrevs[f].remove(flr) | |
| 1952 | |
| 1953 # verify contents | |
| 1954 try: | |
| 1955 t = fl.read(n) | |
| 1956 except Exception, inst: | |
| 1957 self.ui.warn("unpacking file %s %s: %s\n" | |
| 1958 % (f, short(n), inst)) | |
| 1959 errors += 1 | |
| 1960 | |
| 1961 # verify parents | |
| 1962 (p1, p2) = fl.parents(n) | |
| 1963 if p1 not in nodes: | |
| 1964 self.ui.warn("file %s:%s unknown parent 1 %s" % | |
| 1965 (f, short(n), short(p1))) | |
| 1966 errors += 1 | |
| 1967 if p2 not in nodes: | |
| 1968 self.ui.warn("file %s:%s unknown parent 2 %s" % | |
| 1969 (f, short(n), short(p1))) | |
| 1970 errors += 1 | |
| 1971 nodes[n] = 1 | |
| 1972 | |
| 1973 # cross-check | |
| 1974 for node in filenodes[f]: | |
| 1975 self.ui.warn("node %s in manifests not in %s\n" | |
| 721 | 1976 % (hex(node), f)) |
| 247 | 1977 errors += 1 |
| 1978 | |
| 1979 self.ui.status("%d files, %d changesets, %d total revisions\n" % | |
| 1980 (files, changesets, revisions)) | |
| 1981 | |
| 1982 if errors: | |
| 1983 self.ui.warn("%d integrity errors encountered!\n" % errors) | |
| 1984 return 1 | |
| 1985 | |
| 926 | 1986 class remoterepository: |
| 1987 def local(self): | |
| 1988 return False | |
| 1989 | |
| 1990 class httprepository(remoterepository): | |
| 60 | 1991 def __init__(self, ui, path): |
| 765 | 1992 # fix missing / after hostname |
| 1993 s = urlparse.urlsplit(path) | |
| 1994 partial = s[2] | |
| 1995 if not partial: partial = "/" | |
| 1996 self.url = urlparse.urlunsplit((s[0], s[1], partial, '', '')) | |
| 60 | 1997 self.ui = ui |
| 321 | 1998 no_list = [ "localhost", "127.0.0.1" ] |
| 1999 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
|
2000 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
|
2001 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
|
2002 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
|
2003 host = host[7:] |
| 321 | 2004 user = ui.config("http_proxy", "user") |
| 2005 passwd = ui.config("http_proxy", "passwd") | |
| 2006 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
|
2007 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
|
2008 no = os.environ.get("no_proxy") |
| 321 | 2009 if no: |
| 2010 no_list = no_list + no.split(",") | |
| 515 | 2011 |
| 321 | 2012 no_proxy = 0 |
| 2013 for h in no_list: | |
| 2014 if (path.startswith("http://" + h + "/") or | |
| 2015 path.startswith("http://" + h + ":") or | |
| 2016 path == "http://" + h): | |
| 2017 no_proxy = 1 | |
| 2018 | |
| 2019 # Note: urllib2 takes proxy values from the environment and those will | |
| 2020 # 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
|
2021 for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]: |
|
859
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
2022 try: |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
2023 if os.environ.has_key(env): |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
2024 del os.environ[env] |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
2025 except OSError: |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
2026 pass |
| 321 | 2027 |
| 2028 proxy_handler = urllib2.BaseHandler() | |
| 2029 if host and not no_proxy: | |
| 2030 proxy_handler = urllib2.ProxyHandler({"http" : "http://" + host}) | |
| 2031 | |
| 2032 authinfo = None | |
| 2033 if user and passwd: | |
| 2034 passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm() | |
| 2035 passmgr.add_password(None, host, user, passwd) | |
| 2036 authinfo = urllib2.ProxyBasicAuthHandler(passmgr) | |
| 2037 | |
| 2038 opener = urllib2.build_opener(proxy_handler, authinfo) | |
| 2039 urllib2.install_opener(opener) | |
| 60 | 2040 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2041 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2042 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2043 |
| 60 | 2044 def do_cmd(self, cmd, **args): |
| 83 | 2045 self.ui.debug("sending %s command\n" % cmd) |
| 60 | 2046 q = {"cmd": cmd} |
| 2047 q.update(args) | |
| 2048 qs = urllib.urlencode(q) | |
| 2049 cu = "%s?%s" % (self.url, qs) | |
| 752 | 2050 resp = urllib2.urlopen(cu) |
| 753 | 2051 proto = resp.headers['content-type'] |
| 752 | 2052 |
| 753 | 2053 # accept old "text/plain" and "application/hg-changegroup" for now |
| 2054 if not proto.startswith('application/mercurial') and \ | |
| 2055 not proto.startswith('text/plain') and \ | |
| 2056 not proto.startswith('application/hg-changegroup'): | |
| 752 | 2057 raise RepoError("'%s' does not appear to be an hg repository" |
| 2058 % self.url) | |
| 2059 | |
| 753 | 2060 if proto.startswith('application/mercurial'): |
| 2061 version = proto[22:] | |
| 2062 if float(version) > 0.1: | |
| 2063 raise RepoError("'%s' uses newer protocol %s" % | |
| 2064 (self.url, version)) | |
| 2065 | |
| 752 | 2066 return resp |
| 60 | 2067 |
| 222 | 2068 def heads(self): |
| 2069 d = self.do_cmd("heads").read() | |
| 2070 try: | |
| 2071 return map(bin, d[:-1].split(" ")) | |
| 2072 except: | |
| 2073 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 2074 raise | |
| 2075 | |
| 60 | 2076 def branches(self, nodes): |
| 2077 n = " ".join(map(hex, nodes)) | |
| 752 | 2078 d = self.do_cmd("branches", nodes=n).read() |
| 217 | 2079 try: |
| 2080 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ] | |
| 2081 return br | |
| 2082 except: | |
| 2083 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 2084 raise | |
| 60 | 2085 |
| 2086 def between(self, pairs): | |
| 2087 n = "\n".join(["-".join(map(hex, p)) for p in pairs]) | |
| 752 | 2088 d = self.do_cmd("between", pairs=n).read() |
| 217 | 2089 try: |
| 2090 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ] | |
| 2091 return p | |
| 2092 except: | |
| 2093 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 2094 raise | |
| 60 | 2095 |
| 2096 def changegroup(self, nodes): | |
| 2097 n = " ".join(map(hex, nodes)) | |
| 752 | 2098 f = self.do_cmd("changegroup", roots=n) |
| 192 | 2099 bytes = 0 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2100 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2101 class zread: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2102 def __init__(self, f): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2103 self.zd = zlib.decompressobj() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2104 self.f = f |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2105 self.buf = "" |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2106 def read(self, l): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2107 while l > len(self.buf): |
|
751
0b245edec124
When pulling from a non hg repository URL (e.g. http://www.kernel.org/hg)
Muli Ben-Yehuda <mulix@mulix.org>
parents:
741
diff
changeset
|
2108 r = self.f.read(4096) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2109 if r: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2110 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
|
2111 else: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2112 self.buf += self.zd.flush() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2113 break |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2114 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
|
2115 return d |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2116 |
| 752 | 2117 return zread(f) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2118 |
|
638
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2119 class remotelock: |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2120 def __init__(self, repo): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2121 self.repo = repo |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2122 def release(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2123 self.repo.unlock() |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2124 self.repo = None |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2125 def __del__(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2126 if self.repo: |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2127 self.release() |
| 60 | 2128 |
| 926 | 2129 class sshrepository(remoterepository): |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2130 def __init__(self, ui, path): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2131 self.url = path |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2132 self.ui = ui |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2133 |
| 817 | 2134 m = re.match(r'ssh://(([^@]+)@)?([^:/]+)(:(\d+))?(/(.*))', path) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2135 if not m: |
| 817 | 2136 raise RepoError("couldn't parse destination %s" % path) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2137 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2138 self.user = m.group(2) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2139 self.host = m.group(3) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2140 self.port = m.group(5) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2141 self.path = m.group(7) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2142 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2143 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
|
2144 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
|
2145 path = self.path or "" |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2146 |
| 817 | 2147 if not path: |
| 2148 raise RepoError("no remote repository path specified") | |
| 2149 | |
| 961 | 2150 sshcmd = self.ui.config("ui", "ssh", "ssh") |
| 2151 remotecmd = self.ui.config("ui", "remotecmd", "hg") | |
| 2152 cmd = "%s %s '%s -R %s serve --stdio'" | |
| 2153 cmd = cmd % (sshcmd, args, remotecmd, path) | |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2154 |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2155 self.pipeo, self.pipei, self.pipee = os.popen3(cmd) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2156 |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2157 def readerr(self): |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2158 while 1: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2159 r,w,x = select.select([self.pipee], [], [], 0) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2160 if not r: break |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2161 l = self.pipee.readline() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2162 if not l: break |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2163 self.ui.status("remote: ", l) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2164 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2165 def __del__(self): |
| 817 | 2166 try: |
| 2167 self.pipeo.close() | |
| 2168 self.pipei.close() | |
| 2169 for l in self.pipee: | |
| 2170 self.ui.status("remote: ", l) | |
| 2171 self.pipee.close() | |
| 2172 except: | |
| 2173 pass | |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2174 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2175 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2176 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2177 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2178 def do_cmd(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2179 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
|
2180 self.pipeo.write("%s\n" % cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2181 for k, v in args.items(): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2182 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
|
2183 self.pipeo.write(v) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2184 self.pipeo.flush() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2185 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2186 return self.pipei |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2187 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2188 def call(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2189 r = self.do_cmd(cmd, **args) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2190 l = r.readline() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2191 self.readerr() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2192 try: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2193 l = int(l) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2194 except: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2195 raise RepoError("unexpected response '%s'" % l) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2196 return r.read(l) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2197 |
|
638
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2198 def lock(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2199 self.call("lock") |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2200 return remotelock(self) |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2201 |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2202 def unlock(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2203 self.call("unlock") |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2204 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2205 def heads(self): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2206 d = self.call("heads") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2207 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2208 return map(bin, d[:-1].split(" ")) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2209 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2210 raise RepoError("unexpected response '%s'" % (d[:400] + "...")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2211 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2212 def branches(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2213 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2214 d = self.call("branches", nodes=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2215 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2216 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
|
2217 return br |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2218 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2219 raise RepoError("unexpected response '%s'" % (d[:400] + "...")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2220 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2221 def between(self, pairs): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2222 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
|
2223 d = self.call("between", pairs=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2224 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2225 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
|
2226 return p |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2227 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2228 raise RepoError("unexpected response '%s'" % (d[:400] + "...")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2229 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2230 def changegroup(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2231 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2232 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
|
2233 return self.pipei |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2234 |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2235 def addchangegroup(self, cg): |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2236 d = self.call("addchangegroup") |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2237 if d: |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2238 raise RepoError("push refused: %s", d) |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2239 |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2240 while 1: |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2241 d = cg.read(4096) |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2242 if not d: break |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2243 self.pipeo.write(d) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2244 self.readerr() |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2245 |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2246 self.pipeo.flush() |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2247 |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2248 self.readerr() |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2249 l = int(self.pipei.readline()) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2250 return self.pipei.read(l) != "" |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2251 |
| 923 | 2252 class httpsrepository(httprepository): |
| 2253 pass | |
| 2254 | |
| 60 | 2255 def repository(ui, path=None, create=0): |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2256 if path: |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2257 if path.startswith("http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2258 return httprepository(ui, path) |
| 923 | 2259 if path.startswith("https://"): |
| 2260 return httpsrepository(ui, path) | |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2261 if path.startswith("hg://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2262 return httprepository(ui, path.replace("hg://", "http://")) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2263 if path.startswith("old-http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2264 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
|
2265 if path.startswith("ssh://"): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2266 return sshrepository(ui, path) |
| 60 | 2267 |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2268 return localrepository(ui, path, create) |