Show More
@@ -119,7 +119,7 b' def writerevs(ui, r1, r2, order, tr):' | |||||
119 | try: |
|
119 | try: | |
120 | bundler = changegroup.bundle10() |
|
120 | bundler = changegroup.bundle10() | |
121 | bundler.start(lookup) |
|
121 | bundler.start(lookup) | |
122 |
group = util.chunkbuffer(r |
|
122 | group = util.chunkbuffer(bundler.group(order, r1)) | |
123 | group = changegroup.unbundle10(group, "UN") |
|
123 | group = changegroup.unbundle10(group, "UN") | |
124 | r2.addgroup(group, unlookup, tr) |
|
124 | r2.addgroup(group, unlookup, tr) | |
125 | finally: |
|
125 | finally: |
@@ -7,7 +7,7 b'' | |||||
7 |
|
7 | |||
8 | from i18n import _ |
|
8 | from i18n import _ | |
9 | from node import nullrev |
|
9 | from node import nullrev | |
10 | import mdiff, util |
|
10 | import mdiff, util, dagutil | |
11 | import struct, os, bz2, zlib, tempfile |
|
11 | import struct, os, bz2, zlib, tempfile | |
12 |
|
12 | |||
13 | _BUNDLE10_DELTA_HEADER = "20s20s20s20s" |
|
13 | _BUNDLE10_DELTA_HEADER = "20s20s20s20s" | |
@@ -231,8 +231,49 b' class bundle10(object):' | |||||
231 | self._lookup = lookup |
|
231 | self._lookup = lookup | |
232 | def close(self): |
|
232 | def close(self): | |
233 | return closechunk() |
|
233 | return closechunk() | |
|
234 | ||||
234 | def fileheader(self, fname): |
|
235 | def fileheader(self, fname): | |
235 | return chunkheader(len(fname)) + fname |
|
236 | return chunkheader(len(fname)) + fname | |
|
237 | ||||
|
238 | def group(self, nodelist, revlog, reorder=None): | |||
|
239 | """Calculate a delta group, yielding a sequence of changegroup chunks | |||
|
240 | (strings). | |||
|
241 | ||||
|
242 | Given a list of changeset revs, return a set of deltas and | |||
|
243 | metadata corresponding to nodes. The first delta is | |||
|
244 | first parent(nodelist[0]) -> nodelist[0], the receiver is | |||
|
245 | guaranteed to have this parent as it has all history before | |||
|
246 | these changesets. In the case firstparent is nullrev the | |||
|
247 | changegroup starts with a full revision. | |||
|
248 | """ | |||
|
249 | ||||
|
250 | # if we don't have any revisions touched by these changesets, bail | |||
|
251 | if len(nodelist) == 0: | |||
|
252 | yield self.close() | |||
|
253 | return | |||
|
254 | ||||
|
255 | # for generaldelta revlogs, we linearize the revs; this will both be | |||
|
256 | # much quicker and generate a much smaller bundle | |||
|
257 | if (revlog._generaldelta and reorder is not False) or reorder: | |||
|
258 | dag = dagutil.revlogdag(revlog) | |||
|
259 | revs = set(revlog.rev(n) for n in nodelist) | |||
|
260 | revs = dag.linearize(revs) | |||
|
261 | else: | |||
|
262 | revs = sorted([revlog.rev(n) for n in nodelist]) | |||
|
263 | ||||
|
264 | # add the parent of the first rev | |||
|
265 | p = revlog.parentrevs(revs[0])[0] | |||
|
266 | revs.insert(0, p) | |||
|
267 | ||||
|
268 | # build deltas | |||
|
269 | for r in xrange(len(revs) - 1): | |||
|
270 | prev, curr = revs[r], revs[r + 1] | |||
|
271 | for c in self.revchunk(revlog, curr, prev): | |||
|
272 | yield c | |||
|
273 | ||||
|
274 | yield self.close() | |||
|
275 | ||||
|
276 | ||||
236 | def revchunk(self, revlog, rev, prev): |
|
277 | def revchunk(self, revlog, rev, prev): | |
237 | node = revlog.node(rev) |
|
278 | node = revlog.node(rev) | |
238 | p1, p2 = revlog.parentrevs(rev) |
|
279 | p1, p2 = revlog.parentrevs(rev) |
@@ -2092,7 +2092,7 b' class localrepository(object):' | |||||
2092 | # Create a changenode group generator that will call our functions |
|
2092 | # Create a changenode group generator that will call our functions | |
2093 | # back to lookup the owning changenode and collect information. |
|
2093 | # back to lookup the owning changenode and collect information. | |
2094 | count[:] = [0, len(csets)] |
|
2094 | count[:] = [0, len(csets)] | |
2095 |
for chunk in |
|
2095 | for chunk in bundler.group(csets, cl, reorder=reorder): | |
2096 | yield chunk |
|
2096 | yield chunk | |
2097 | progress(_bundling, None) |
|
2097 | progress(_bundling, None) | |
2098 |
|
2098 | |||
@@ -2101,7 +2101,7 b' class localrepository(object):' | |||||
2101 | for f in changedfiles: |
|
2101 | for f in changedfiles: | |
2102 | fnodes[f] = {} |
|
2102 | fnodes[f] = {} | |
2103 | count[:] = [0, len(mfs)] |
|
2103 | count[:] = [0, len(mfs)] | |
2104 |
for chunk in |
|
2104 | for chunk in bundler.group(prune(mf, mfs), mf, reorder=reorder): | |
2105 | yield chunk |
|
2105 | yield chunk | |
2106 | progress(_bundling, None) |
|
2106 | progress(_bundling, None) | |
2107 |
|
2107 | |||
@@ -2121,7 +2121,7 b' class localrepository(object):' | |||||
2121 | if nodelist: |
|
2121 | if nodelist: | |
2122 | count[0] += 1 |
|
2122 | count[0] += 1 | |
2123 | yield bundler.fileheader(fname) |
|
2123 | yield bundler.fileheader(fname) | |
2124 |
for chunk in |
|
2124 | for chunk in bundler.group(nodelist, filerevlog, reorder): | |
2125 | yield chunk |
|
2125 | yield chunk | |
2126 |
|
2126 | |||
2127 | # Signal that no more groups are left. |
|
2127 | # Signal that no more groups are left. | |
@@ -2201,12 +2201,12 b' class localrepository(object):' | |||||
2201 | # construct a list of all changed files |
|
2201 | # construct a list of all changed files | |
2202 |
|
2202 | |||
2203 | count[:] = [0, len(nodes)] |
|
2203 | count[:] = [0, len(nodes)] | |
2204 |
for chunk in |
|
2204 | for chunk in bundler.group(nodes, cl, reorder=reorder): | |
2205 | yield chunk |
|
2205 | yield chunk | |
2206 | progress(_bundling, None) |
|
2206 | progress(_bundling, None) | |
2207 |
|
2207 | |||
2208 | count[:] = [0, len(mfs)] |
|
2208 | count[:] = [0, len(mfs)] | |
2209 |
for chunk in |
|
2209 | for chunk in bundler.group(gennodelst(mf), mf, reorder=reorder): | |
2210 | yield chunk |
|
2210 | yield chunk | |
2211 | progress(_bundling, None) |
|
2211 | progress(_bundling, None) | |
2212 |
|
2212 | |||
@@ -2221,7 +2221,7 b' class localrepository(object):' | |||||
2221 | if nodelist: |
|
2221 | if nodelist: | |
2222 | count[0] += 1 |
|
2222 | count[0] += 1 | |
2223 | yield bundler.fileheader(fname) |
|
2223 | yield bundler.fileheader(fname) | |
2224 |
for chunk in |
|
2224 | for chunk in bundler.group(nodelist, filerevlog, reorder): | |
2225 | yield chunk |
|
2225 | yield chunk | |
2226 | yield bundler.close() |
|
2226 | yield bundler.close() | |
2227 | progress(_bundling, None) |
|
2227 | progress(_bundling, None) |
@@ -14,7 +14,7 b' and O(changes) merge between branches.' | |||||
14 | # import stuff from node for others to import from revlog |
|
14 | # import stuff from node for others to import from revlog | |
15 | from node import bin, hex, nullid, nullrev |
|
15 | from node import bin, hex, nullid, nullrev | |
16 | from i18n import _ |
|
16 | from i18n import _ | |
17 |
import ancestor, mdiff, parsers, error, util |
|
17 | import ancestor, mdiff, parsers, error, util | |
18 | import struct, zlib, errno |
|
18 | import struct, zlib, errno | |
19 |
|
19 | |||
20 | _pack = struct.pack |
|
20 | _pack = struct.pack | |
@@ -1143,44 +1143,6 b' class revlog(object):' | |||||
1143 | self._basecache = (curr, chainbase) |
|
1143 | self._basecache = (curr, chainbase) | |
1144 | return node |
|
1144 | return node | |
1145 |
|
1145 | |||
1146 | def group(self, nodelist, bundler, reorder=None): |
|
|||
1147 | """Calculate a delta group, yielding a sequence of changegroup chunks |
|
|||
1148 | (strings). |
|
|||
1149 |
|
||||
1150 | Given a list of changeset revs, return a set of deltas and |
|
|||
1151 | metadata corresponding to nodes. The first delta is |
|
|||
1152 | first parent(nodelist[0]) -> nodelist[0], the receiver is |
|
|||
1153 | guaranteed to have this parent as it has all history before |
|
|||
1154 | these changesets. In the case firstparent is nullrev the |
|
|||
1155 | changegroup starts with a full revision. |
|
|||
1156 | """ |
|
|||
1157 |
|
||||
1158 | # if we don't have any revisions touched by these changesets, bail |
|
|||
1159 | if len(nodelist) == 0: |
|
|||
1160 | yield bundler.close() |
|
|||
1161 | return |
|
|||
1162 |
|
||||
1163 | # for generaldelta revlogs, we linearize the revs; this will both be |
|
|||
1164 | # much quicker and generate a much smaller bundle |
|
|||
1165 | if (self._generaldelta and reorder is not False) or reorder: |
|
|||
1166 | dag = dagutil.revlogdag(self) |
|
|||
1167 | revs = set(self.rev(n) for n in nodelist) |
|
|||
1168 | revs = dag.linearize(revs) |
|
|||
1169 | else: |
|
|||
1170 | revs = sorted([self.rev(n) for n in nodelist]) |
|
|||
1171 |
|
||||
1172 | # add the parent of the first rev |
|
|||
1173 | p = self.parentrevs(revs[0])[0] |
|
|||
1174 | revs.insert(0, p) |
|
|||
1175 |
|
||||
1176 | # build deltas |
|
|||
1177 | for r in xrange(len(revs) - 1): |
|
|||
1178 | prev, curr = revs[r], revs[r + 1] |
|
|||
1179 | for c in bundler.revchunk(self, curr, prev): |
|
|||
1180 | yield c |
|
|||
1181 |
|
||||
1182 | yield bundler.close() |
|
|||
1183 |
|
||||
1184 | def addgroup(self, bundle, linkmapper, transaction): |
|
1146 | def addgroup(self, bundle, linkmapper, transaction): | |
1185 | """ |
|
1147 | """ | |
1186 | add a delta group |
|
1148 | add a delta group |
General Comments 0
You need to be logged in to leave comments.
Login now