Show More
@@ -119,7 +119,7 b' def writerevs(ui, r1, r2, order, tr):' | |||
|
119 | 119 | try: |
|
120 | 120 | bundler = changegroup.bundle10() |
|
121 | 121 | bundler.start(lookup) |
|
122 |
group = util.chunkbuffer(r |
|
|
122 | group = util.chunkbuffer(bundler.group(order, r1)) | |
|
123 | 123 | group = changegroup.unbundle10(group, "UN") |
|
124 | 124 | r2.addgroup(group, unlookup, tr) |
|
125 | 125 | finally: |
@@ -7,7 +7,7 b'' | |||
|
7 | 7 | |
|
8 | 8 | from i18n import _ |
|
9 | 9 | from node import nullrev |
|
10 | import mdiff, util | |
|
10 | import mdiff, util, dagutil | |
|
11 | 11 | import struct, os, bz2, zlib, tempfile |
|
12 | 12 | |
|
13 | 13 | _BUNDLE10_DELTA_HEADER = "20s20s20s20s" |
@@ -231,8 +231,49 b' class bundle10(object):' | |||
|
231 | 231 | self._lookup = lookup |
|
232 | 232 | def close(self): |
|
233 | 233 | return closechunk() |
|
234 | ||
|
234 | 235 | def fileheader(self, fname): |
|
235 | 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 | 277 | def revchunk(self, revlog, rev, prev): |
|
237 | 278 | node = revlog.node(rev) |
|
238 | 279 | p1, p2 = revlog.parentrevs(rev) |
@@ -2092,7 +2092,7 b' class localrepository(object):' | |||
|
2092 | 2092 | # Create a changenode group generator that will call our functions |
|
2093 | 2093 | # back to lookup the owning changenode and collect information. |
|
2094 | 2094 | count[:] = [0, len(csets)] |
|
2095 |
for chunk in |
|
|
2095 | for chunk in bundler.group(csets, cl, reorder=reorder): | |
|
2096 | 2096 | yield chunk |
|
2097 | 2097 | progress(_bundling, None) |
|
2098 | 2098 | |
@@ -2101,7 +2101,7 b' class localrepository(object):' | |||
|
2101 | 2101 | for f in changedfiles: |
|
2102 | 2102 | fnodes[f] = {} |
|
2103 | 2103 | count[:] = [0, len(mfs)] |
|
2104 |
for chunk in |
|
|
2104 | for chunk in bundler.group(prune(mf, mfs), mf, reorder=reorder): | |
|
2105 | 2105 | yield chunk |
|
2106 | 2106 | progress(_bundling, None) |
|
2107 | 2107 | |
@@ -2121,7 +2121,7 b' class localrepository(object):' | |||
|
2121 | 2121 | if nodelist: |
|
2122 | 2122 | count[0] += 1 |
|
2123 | 2123 | yield bundler.fileheader(fname) |
|
2124 |
for chunk in |
|
|
2124 | for chunk in bundler.group(nodelist, filerevlog, reorder): | |
|
2125 | 2125 | yield chunk |
|
2126 | 2126 | |
|
2127 | 2127 | # Signal that no more groups are left. |
@@ -2201,12 +2201,12 b' class localrepository(object):' | |||
|
2201 | 2201 | # construct a list of all changed files |
|
2202 | 2202 | |
|
2203 | 2203 | count[:] = [0, len(nodes)] |
|
2204 |
for chunk in |
|
|
2204 | for chunk in bundler.group(nodes, cl, reorder=reorder): | |
|
2205 | 2205 | yield chunk |
|
2206 | 2206 | progress(_bundling, None) |
|
2207 | 2207 | |
|
2208 | 2208 | count[:] = [0, len(mfs)] |
|
2209 |
for chunk in |
|
|
2209 | for chunk in bundler.group(gennodelst(mf), mf, reorder=reorder): | |
|
2210 | 2210 | yield chunk |
|
2211 | 2211 | progress(_bundling, None) |
|
2212 | 2212 | |
@@ -2221,7 +2221,7 b' class localrepository(object):' | |||
|
2221 | 2221 | if nodelist: |
|
2222 | 2222 | count[0] += 1 |
|
2223 | 2223 | yield bundler.fileheader(fname) |
|
2224 |
for chunk in |
|
|
2224 | for chunk in bundler.group(nodelist, filerevlog, reorder): | |
|
2225 | 2225 | yield chunk |
|
2226 | 2226 | yield bundler.close() |
|
2227 | 2227 | progress(_bundling, None) |
@@ -14,7 +14,7 b' and O(changes) merge between branches.' | |||
|
14 | 14 | # import stuff from node for others to import from revlog |
|
15 | 15 | from node import bin, hex, nullid, nullrev |
|
16 | 16 | from i18n import _ |
|
17 |
import ancestor, mdiff, parsers, error, util |
|
|
17 | import ancestor, mdiff, parsers, error, util | |
|
18 | 18 | import struct, zlib, errno |
|
19 | 19 | |
|
20 | 20 | _pack = struct.pack |
@@ -1143,44 +1143,6 b' class revlog(object):' | |||
|
1143 | 1143 | self._basecache = (curr, chainbase) |
|
1144 | 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 | 1146 | def addgroup(self, bundle, linkmapper, transaction): |
|
1185 | 1147 | """ |
|
1186 | 1148 | add a delta group |
General Comments 0
You need to be logged in to leave comments.
Login now