##// END OF EJS Templates
setdiscovery: fix a few typos...
Joerg Sonnenberger -
r42346:644eaffa default draft
parent child Browse files
Show More
@@ -1,436 +1,436 b''
1 # setdiscovery.py - improved discovery of common nodeset for mercurial
1 # setdiscovery.py - improved discovery of common nodeset for mercurial
2 #
2 #
3 # Copyright 2010 Benoit Boissinot <bboissin@gmail.com>
3 # Copyright 2010 Benoit Boissinot <bboissin@gmail.com>
4 # and Peter Arrenbrecht <peter@arrenbrecht.ch>
4 # and Peter Arrenbrecht <peter@arrenbrecht.ch>
5 #
5 #
6 # This software may be used and distributed according to the terms of the
6 # This software may be used and distributed according to the terms of the
7 # GNU General Public License version 2 or any later version.
7 # GNU General Public License version 2 or any later version.
8 """
8 """
9 Algorithm works in the following way. You have two repository: local and
9 Algorithm works in the following way. You have two repository: local and
10 remote. They both contains a DAG of changelists.
10 remote. They both contains a DAG of changelists.
11
11
12 The goal of the discovery protocol is to find one set of node *common*,
12 The goal of the discovery protocol is to find one set of node *common*,
13 the set of nodes shared by local and remote.
13 the set of nodes shared by local and remote.
14
14
15 One of the issue with the original protocol was latency, it could
15 One of the issue with the original protocol was latency, it could
16 potentially require lots of roundtrips to discover that the local repo was a
16 potentially require lots of roundtrips to discover that the local repo was a
17 subset of remote (which is a very common case, you usually have few changes
17 subset of remote (which is a very common case, you usually have few changes
18 compared to upstream, while upstream probably had lots of development).
18 compared to upstream, while upstream probably had lots of development).
19
19
20 The new protocol only requires one interface for the remote repo: `known()`,
20 The new protocol only requires one interface for the remote repo: `known()`,
21 which given a set of changelists tells you if they are present in the DAG.
21 which given a set of changelists tells you if they are present in the DAG.
22
22
23 The algorithm then works as follow:
23 The algorithm then works as follow:
24
24
25 - We will be using three sets, `common`, `missing`, `unknown`. Originally
25 - We will be using three sets, `common`, `missing`, `unknown`. Originally
26 all nodes are in `unknown`.
26 all nodes are in `unknown`.
27 - Take a sample from `unknown`, call `remote.known(sample)`
27 - Take a sample from `unknown`, call `remote.known(sample)`
28 - For each node that remote knows, move it and all its ancestors to `common`
28 - For each node that remote knows, move it and all its ancestors to `common`
29 - For each node that remote doesn't know, move it and all its descendants
29 - For each node that remote doesn't know, move it and all its descendants
30 to `missing`
30 to `missing`
31 - Iterate until `unknown` is empty
31 - Iterate until `unknown` is empty
32
32
33 There are a couple optimizations, first is instead of starting with a random
33 There are a couple optimizations, first is instead of starting with a random
34 sample of missing, start by sending all heads, in the case where the local
34 sample of missing, start by sending all heads, in the case where the local
35 repo is a subset, you computed the answer in one round trip.
35 repo is a subset, you computed the answer in one round trip.
36
36
37 Then you can do something similar to the bisecting strategy used when
37 Then you can do something similar to the bisecting strategy used when
38 finding faulty changesets. Instead of random samples, you can try picking
38 finding faulty changesets. Instead of random samples, you can try picking
39 nodes that will maximize the number of nodes that will be
39 nodes that will maximize the number of nodes that will be
40 classified with it (since all ancestors or descendants will be marked as well).
40 classified with it (since all ancestors or descendants will be marked as well).
41 """
41 """
42
42
43 from __future__ import absolute_import
43 from __future__ import absolute_import
44
44
45 import collections
45 import collections
46 import random
46 import random
47
47
48 from .i18n import _
48 from .i18n import _
49 from .node import (
49 from .node import (
50 nullid,
50 nullid,
51 nullrev,
51 nullrev,
52 )
52 )
53 from . import (
53 from . import (
54 error,
54 error,
55 util,
55 util,
56 )
56 )
57
57
58 def _updatesample(revs, heads, sample, parentfn, quicksamplesize=0):
58 def _updatesample(revs, heads, sample, parentfn, quicksamplesize=0):
59 """update an existing sample to match the expected size
59 """update an existing sample to match the expected size
60
60
61 The sample is updated with revs exponentially distant from each head of the
61 The sample is updated with revs exponentially distant from each head of the
62 <revs> set. (H~1, H~2, H~4, H~8, etc).
62 <revs> set. (H~1, H~2, H~4, H~8, etc).
63
63
64 If a target size is specified, the sampling will stop once this size is
64 If a target size is specified, the sampling will stop once this size is
65 reached. Otherwise sampling will happen until roots of the <revs> set are
65 reached. Otherwise sampling will happen until roots of the <revs> set are
66 reached.
66 reached.
67
67
68 :revs: set of revs we want to discover (if None, assume the whole dag)
68 :revs: set of revs we want to discover (if None, assume the whole dag)
69 :heads: set of DAG head revs
69 :heads: set of DAG head revs
70 :sample: a sample to update
70 :sample: a sample to update
71 :parentfn: a callable to resolve parents for a revision
71 :parentfn: a callable to resolve parents for a revision
72 :quicksamplesize: optional target size of the sample"""
72 :quicksamplesize: optional target size of the sample"""
73 dist = {}
73 dist = {}
74 visit = collections.deque(heads)
74 visit = collections.deque(heads)
75 seen = set()
75 seen = set()
76 factor = 1
76 factor = 1
77 while visit:
77 while visit:
78 curr = visit.popleft()
78 curr = visit.popleft()
79 if curr in seen:
79 if curr in seen:
80 continue
80 continue
81 d = dist.setdefault(curr, 1)
81 d = dist.setdefault(curr, 1)
82 if d > factor:
82 if d > factor:
83 factor *= 2
83 factor *= 2
84 if d == factor:
84 if d == factor:
85 sample.add(curr)
85 sample.add(curr)
86 if quicksamplesize and (len(sample) >= quicksamplesize):
86 if quicksamplesize and (len(sample) >= quicksamplesize):
87 return
87 return
88 seen.add(curr)
88 seen.add(curr)
89
89
90 for p in parentfn(curr):
90 for p in parentfn(curr):
91 if p != nullrev and (not revs or p in revs):
91 if p != nullrev and (not revs or p in revs):
92 dist.setdefault(p, d + 1)
92 dist.setdefault(p, d + 1)
93 visit.append(p)
93 visit.append(p)
94
94
95 def _limitsample(sample, desiredlen):
95 def _limitsample(sample, desiredlen):
96 """return a random subset of sample of at most desiredlen item"""
96 """return a random subset of sample of at most desiredlen item"""
97 if len(sample) > desiredlen:
97 if len(sample) > desiredlen:
98 sample = set(random.sample(sample, desiredlen))
98 sample = set(random.sample(sample, desiredlen))
99 return sample
99 return sample
100
100
101 class partialdiscovery(object):
101 class partialdiscovery(object):
102 """an object representing ongoing discovery
102 """an object representing ongoing discovery
103
103
104 Feed with data from the remote repository, this object keep track of the
104 Feed with data from the remote repository, this object keep track of the
105 current set of changeset in various states:
105 current set of changeset in various states:
106
106
107 - common: revs also known remotely
107 - common: revs also known remotely
108 - undecided: revs we don't have information on yet
108 - undecided: revs we don't have information on yet
109 - missing: revs missing remotely
109 - missing: revs missing remotely
110 (all tracked revisions are known locally)
110 (all tracked revisions are known locally)
111 """
111 """
112
112
113 def __init__(self, repo, targetheads):
113 def __init__(self, repo, targetheads):
114 self._repo = repo
114 self._repo = repo
115 self._targetheads = targetheads
115 self._targetheads = targetheads
116 self._common = repo.changelog.incrementalmissingrevs()
116 self._common = repo.changelog.incrementalmissingrevs()
117 self._undecided = None
117 self._undecided = None
118 self.missing = set()
118 self.missing = set()
119 self._childrenmap = None
119 self._childrenmap = None
120
120
121 def addcommons(self, commons):
121 def addcommons(self, commons):
122 """registrer nodes known as common"""
122 """register nodes known as common"""
123 self._common.addbases(commons)
123 self._common.addbases(commons)
124 if self._undecided is not None:
124 if self._undecided is not None:
125 self._common.removeancestorsfrom(self._undecided)
125 self._common.removeancestorsfrom(self._undecided)
126
126
127 def addmissings(self, missings):
127 def addmissings(self, missings):
128 """registrer some nodes as missing"""
128 """register some nodes as missing"""
129 newmissing = self._repo.revs('%ld::%ld', missings, self.undecided)
129 newmissing = self._repo.revs('%ld::%ld', missings, self.undecided)
130 if newmissing:
130 if newmissing:
131 self.missing.update(newmissing)
131 self.missing.update(newmissing)
132 self.undecided.difference_update(newmissing)
132 self.undecided.difference_update(newmissing)
133
133
134 def addinfo(self, sample):
134 def addinfo(self, sample):
135 """consume an iterable of (rev, known) tuples"""
135 """consume an iterable of (rev, known) tuples"""
136 common = set()
136 common = set()
137 missing = set()
137 missing = set()
138 for rev, known in sample:
138 for rev, known in sample:
139 if known:
139 if known:
140 common.add(rev)
140 common.add(rev)
141 else:
141 else:
142 missing.add(rev)
142 missing.add(rev)
143 if common:
143 if common:
144 self.addcommons(common)
144 self.addcommons(common)
145 if missing:
145 if missing:
146 self.addmissings(missing)
146 self.addmissings(missing)
147
147
148 def hasinfo(self):
148 def hasinfo(self):
149 """return True is we have any clue about the remote state"""
149 """return True is we have any clue about the remote state"""
150 return self._common.hasbases()
150 return self._common.hasbases()
151
151
152 def iscomplete(self):
152 def iscomplete(self):
153 """True if all the necessary data have been gathered"""
153 """True if all the necessary data have been gathered"""
154 return self._undecided is not None and not self._undecided
154 return self._undecided is not None and not self._undecided
155
155
156 @property
156 @property
157 def undecided(self):
157 def undecided(self):
158 if self._undecided is not None:
158 if self._undecided is not None:
159 return self._undecided
159 return self._undecided
160 self._undecided = set(self._common.missingancestors(self._targetheads))
160 self._undecided = set(self._common.missingancestors(self._targetheads))
161 return self._undecided
161 return self._undecided
162
162
163 def stats(self):
163 def stats(self):
164 return {
164 return {
165 'undecided': len(self.undecided),
165 'undecided': len(self.undecided),
166 }
166 }
167
167
168 def commonheads(self):
168 def commonheads(self):
169 """the heads of the known common set"""
169 """the heads of the known common set"""
170 # heads(common) == heads(common.bases) since common represents
170 # heads(common) == heads(common.bases) since common represents
171 # common.bases and all its ancestors
171 # common.bases and all its ancestors
172 return self._common.basesheads()
172 return self._common.basesheads()
173
173
174 def _parentsgetter(self):
174 def _parentsgetter(self):
175 getrev = self._repo.changelog.index.__getitem__
175 getrev = self._repo.changelog.index.__getitem__
176 def getparents(r):
176 def getparents(r):
177 return getrev(r)[5:7]
177 return getrev(r)[5:7]
178 return getparents
178 return getparents
179
179
180 def _childrengetter(self):
180 def _childrengetter(self):
181
181
182 if self._childrenmap is not None:
182 if self._childrenmap is not None:
183 # During discovery, the `undecided` set keep shrinking.
183 # During discovery, the `undecided` set keep shrinking.
184 # Therefore, the map computed for an iteration N will be
184 # Therefore, the map computed for an iteration N will be
185 # valid for iteration N+1. Instead of computing the same
185 # valid for iteration N+1. Instead of computing the same
186 # data over and over we cached it the first time.
186 # data over and over we cached it the first time.
187 return self._childrenmap.__getitem__
187 return self._childrenmap.__getitem__
188
188
189 # _updatesample() essentially does interaction over revisions to look
189 # _updatesample() essentially does interaction over revisions to look
190 # up their children. This lookup is expensive and doing it in a loop is
190 # up their children. This lookup is expensive and doing it in a loop is
191 # quadratic. We precompute the children for all relevant revisions and
191 # quadratic. We precompute the children for all relevant revisions and
192 # make the lookup in _updatesample() a simple dict lookup.
192 # make the lookup in _updatesample() a simple dict lookup.
193 self._childrenmap = children = {}
193 self._childrenmap = children = {}
194
194
195 parentrevs = self._parentsgetter()
195 parentrevs = self._parentsgetter()
196 revs = self.undecided
196 revs = self.undecided
197
197
198 for rev in sorted(revs):
198 for rev in sorted(revs):
199 # Always ensure revision has an entry so we don't need to worry
199 # Always ensure revision has an entry so we don't need to worry
200 # about missing keys.
200 # about missing keys.
201 children[rev] = []
201 children[rev] = []
202 for prev in parentrevs(rev):
202 for prev in parentrevs(rev):
203 if prev == nullrev:
203 if prev == nullrev:
204 continue
204 continue
205 c = children.get(prev)
205 c = children.get(prev)
206 if c is not None:
206 if c is not None:
207 c.append(rev)
207 c.append(rev)
208 return children.__getitem__
208 return children.__getitem__
209
209
210 def takequicksample(self, headrevs, size):
210 def takequicksample(self, headrevs, size):
211 """takes a quick sample of size <size>
211 """takes a quick sample of size <size>
212
212
213 It is meant for initial sampling and focuses on querying heads and close
213 It is meant for initial sampling and focuses on querying heads and close
214 ancestors of heads.
214 ancestors of heads.
215
215
216 :headrevs: set of head revisions in local DAG to consider
216 :headrevs: set of head revisions in local DAG to consider
217 :size: the maximum size of the sample"""
217 :size: the maximum size of the sample"""
218 revs = self.undecided
218 revs = self.undecided
219 if len(revs) <= size:
219 if len(revs) <= size:
220 return list(revs)
220 return list(revs)
221 sample = set(self._repo.revs('heads(%ld)', revs))
221 sample = set(self._repo.revs('heads(%ld)', revs))
222
222
223 if len(sample) >= size:
223 if len(sample) >= size:
224 return _limitsample(sample, size)
224 return _limitsample(sample, size)
225
225
226 _updatesample(None, headrevs, sample, self._parentsgetter(),
226 _updatesample(None, headrevs, sample, self._parentsgetter(),
227 quicksamplesize=size)
227 quicksamplesize=size)
228 return sample
228 return sample
229
229
230 def takefullsample(self, headrevs, size):
230 def takefullsample(self, headrevs, size):
231 revs = self.undecided
231 revs = self.undecided
232 if len(revs) <= size:
232 if len(revs) <= size:
233 return list(revs)
233 return list(revs)
234 repo = self._repo
234 repo = self._repo
235 sample = set(repo.revs('heads(%ld)', revs))
235 sample = set(repo.revs('heads(%ld)', revs))
236 parentrevs = self._parentsgetter()
236 parentrevs = self._parentsgetter()
237
237
238 # update from heads
238 # update from heads
239 revsheads = sample.copy()
239 revsheads = sample.copy()
240 _updatesample(revs, revsheads, sample, parentrevs)
240 _updatesample(revs, revsheads, sample, parentrevs)
241
241
242 # update from roots
242 # update from roots
243 revsroots = set(repo.revs('roots(%ld)', revs))
243 revsroots = set(repo.revs('roots(%ld)', revs))
244
244
245 childrenrevs = self._childrengetter()
245 childrenrevs = self._childrengetter()
246
246
247 _updatesample(revs, revsroots, sample, childrenrevs)
247 _updatesample(revs, revsroots, sample, childrenrevs)
248 assert sample
248 assert sample
249 sample = _limitsample(sample, size)
249 sample = _limitsample(sample, size)
250 if len(sample) < size:
250 if len(sample) < size:
251 more = size - len(sample)
251 more = size - len(sample)
252 sample.update(random.sample(list(revs - sample), more))
252 sample.update(random.sample(list(revs - sample), more))
253 return sample
253 return sample
254
254
255 def findcommonheads(ui, local, remote,
255 def findcommonheads(ui, local, remote,
256 initialsamplesize=100,
256 initialsamplesize=100,
257 fullsamplesize=200,
257 fullsamplesize=200,
258 abortwhenunrelated=True,
258 abortwhenunrelated=True,
259 ancestorsof=None):
259 ancestorsof=None):
260 '''Return a tuple (common, anyincoming, remoteheads) used to identify
260 '''Return a tuple (common, anyincoming, remoteheads) used to identify
261 missing nodes from or in remote.
261 missing nodes from or in remote.
262 '''
262 '''
263 start = util.timer()
263 start = util.timer()
264
264
265 roundtrips = 0
265 roundtrips = 0
266 cl = local.changelog
266 cl = local.changelog
267 clnode = cl.node
267 clnode = cl.node
268 clrev = cl.rev
268 clrev = cl.rev
269
269
270 if ancestorsof is not None:
270 if ancestorsof is not None:
271 ownheads = [clrev(n) for n in ancestorsof]
271 ownheads = [clrev(n) for n in ancestorsof]
272 else:
272 else:
273 ownheads = [rev for rev in cl.headrevs() if rev != nullrev]
273 ownheads = [rev for rev in cl.headrevs() if rev != nullrev]
274
274
275 # early exit if we know all the specified remote heads already
275 # early exit if we know all the specified remote heads already
276 ui.debug("query 1; heads\n")
276 ui.debug("query 1; heads\n")
277 roundtrips += 1
277 roundtrips += 1
278 # We also ask remote about all the local heads. That set can be arbitrarily
278 # We also ask remote about all the local heads. That set can be arbitrarily
279 # large, so we used to limit it size to `initialsamplesize`. We no longer
279 # large, so we used to limit it size to `initialsamplesize`. We no longer
280 # do as it proved counter productive. The skipped heads could lead to a
280 # do as it proved counter productive. The skipped heads could lead to a
281 # large "undecided" set, slower to be clarified than if we asked the
281 # large "undecided" set, slower to be clarified than if we asked the
282 # question for all heads right away.
282 # question for all heads right away.
283 #
283 #
284 # We are already fetching all server heads using the `heads` commands,
284 # We are already fetching all server heads using the `heads` commands,
285 # sending a equivalent number of heads the other way should not have a
285 # sending a equivalent number of heads the other way should not have a
286 # significant impact. In addition, it is very likely that we are going to
286 # significant impact. In addition, it is very likely that we are going to
287 # have to issue "known" request for an equivalent amount of revisions in
287 # have to issue "known" request for an equivalent amount of revisions in
288 # order to decide if theses heads are common or missing.
288 # order to decide if theses heads are common or missing.
289 #
289 #
290 # find a detailled analysis below.
290 # find a detailled analysis below.
291 #
291 #
292 # Case A: local and server both has few heads
292 # Case A: local and server both has few heads
293 #
293 #
294 # Ownheads is below initialsamplesize, limit would not have any effect.
294 # Ownheads is below initialsamplesize, limit would not have any effect.
295 #
295 #
296 # Case B: local has few heads and server has many
296 # Case B: local has few heads and server has many
297 #
297 #
298 # Ownheads is below initialsamplesize, limit would not have any effect.
298 # Ownheads is below initialsamplesize, limit would not have any effect.
299 #
299 #
300 # Case C: local and server both has many heads
300 # Case C: local and server both has many heads
301 #
301 #
302 # We now transfert some more data, but not significantly more than is
302 # We now transfert some more data, but not significantly more than is
303 # already transfered to carry the server heads.
303 # already transfered to carry the server heads.
304 #
304 #
305 # Case D: local has many heads, server has few
305 # Case D: local has many heads, server has few
306 #
306 #
307 # D.1 local heads are mostly known remotely
307 # D.1 local heads are mostly known remotely
308 #
308 #
309 # All the known head will have be part of a `known` request at some
309 # All the known head will have be part of a `known` request at some
310 # point for the discovery to finish. Sending them all earlier is
310 # point for the discovery to finish. Sending them all earlier is
311 # actually helping.
311 # actually helping.
312 #
312 #
313 # (This case is fairly unlikely, it requires the numerous heads to all
313 # (This case is fairly unlikely, it requires the numerous heads to all
314 # be merged server side in only a few heads)
314 # be merged server side in only a few heads)
315 #
315 #
316 # D.2 local heads are mostly missing remotely
316 # D.2 local heads are mostly missing remotely
317 #
317 #
318 # To determine that the heads are missing, we'll have to issue `known`
318 # To determine that the heads are missing, we'll have to issue `known`
319 # request for them or one of their ancestors. This amount of `known`
319 # request for them or one of their ancestors. This amount of `known`
320 # request will likely be in the same order of magnitude than the amount
320 # request will likely be in the same order of magnitude than the amount
321 # of local heads.
321 # of local heads.
322 #
322 #
323 # The only case where we can be more efficient using `known` request on
323 # The only case where we can be more efficient using `known` request on
324 # ancestors are case were all the "missing" local heads are based on a
324 # ancestors are case were all the "missing" local heads are based on a
325 # few changeset, also "missing". This means we would have a "complex"
325 # few changeset, also "missing". This means we would have a "complex"
326 # graph (with many heads) attached to, but very independant to a the
326 # graph (with many heads) attached to, but very independant to a the
327 # "simple" graph on the server. This is a fairly usual case and have
327 # "simple" graph on the server. This is a fairly usual case and have
328 # not been met in the wild so far.
328 # not been met in the wild so far.
329 if remote.limitedarguments:
329 if remote.limitedarguments:
330 sample = _limitsample(ownheads, initialsamplesize)
330 sample = _limitsample(ownheads, initialsamplesize)
331 # indices between sample and externalized version must match
331 # indices between sample and externalized version must match
332 sample = list(sample)
332 sample = list(sample)
333 else:
333 else:
334 sample = ownheads
334 sample = ownheads
335
335
336 with remote.commandexecutor() as e:
336 with remote.commandexecutor() as e:
337 fheads = e.callcommand('heads', {})
337 fheads = e.callcommand('heads', {})
338 fknown = e.callcommand('known', {
338 fknown = e.callcommand('known', {
339 'nodes': [clnode(r) for r in sample],
339 'nodes': [clnode(r) for r in sample],
340 })
340 })
341
341
342 srvheadhashes, yesno = fheads.result(), fknown.result()
342 srvheadhashes, yesno = fheads.result(), fknown.result()
343
343
344 if cl.tip() == nullid:
344 if cl.tip() == nullid:
345 if srvheadhashes != [nullid]:
345 if srvheadhashes != [nullid]:
346 return [nullid], True, srvheadhashes
346 return [nullid], True, srvheadhashes
347 return [nullid], False, []
347 return [nullid], False, []
348
348
349 # start actual discovery (we note this before the next "if" for
349 # start actual discovery (we note this before the next "if" for
350 # compatibility reasons)
350 # compatibility reasons)
351 ui.status(_("searching for changes\n"))
351 ui.status(_("searching for changes\n"))
352
352
353 knownsrvheads = [] # revnos of remote heads that are known locally
353 knownsrvheads = [] # revnos of remote heads that are known locally
354 for node in srvheadhashes:
354 for node in srvheadhashes:
355 if node == nullid:
355 if node == nullid:
356 continue
356 continue
357
357
358 try:
358 try:
359 knownsrvheads.append(clrev(node))
359 knownsrvheads.append(clrev(node))
360 # Catches unknown and filtered nodes.
360 # Catches unknown and filtered nodes.
361 except error.LookupError:
361 except error.LookupError:
362 continue
362 continue
363
363
364 if len(knownsrvheads) == len(srvheadhashes):
364 if len(knownsrvheads) == len(srvheadhashes):
365 ui.debug("all remote heads known locally\n")
365 ui.debug("all remote heads known locally\n")
366 return srvheadhashes, False, srvheadhashes
366 return srvheadhashes, False, srvheadhashes
367
367
368 if len(sample) == len(ownheads) and all(yesno):
368 if len(sample) == len(ownheads) and all(yesno):
369 ui.note(_("all local heads known remotely\n"))
369 ui.note(_("all local heads known remotely\n"))
370 ownheadhashes = [clnode(r) for r in ownheads]
370 ownheadhashes = [clnode(r) for r in ownheads]
371 return ownheadhashes, True, srvheadhashes
371 return ownheadhashes, True, srvheadhashes
372
372
373 # full blown discovery
373 # full blown discovery
374
374
375 disco = partialdiscovery(local, ownheads)
375 disco = partialdiscovery(local, ownheads)
376 # treat remote heads (and maybe own heads) as a first implicit sample
376 # treat remote heads (and maybe own heads) as a first implicit sample
377 # response
377 # response
378 disco.addcommons(knownsrvheads)
378 disco.addcommons(knownsrvheads)
379 disco.addinfo(zip(sample, yesno))
379 disco.addinfo(zip(sample, yesno))
380
380
381 full = False
381 full = False
382 progress = ui.makeprogress(_('searching'), unit=_('queries'))
382 progress = ui.makeprogress(_('searching'), unit=_('queries'))
383 while not disco.iscomplete():
383 while not disco.iscomplete():
384
384
385 if full or disco.hasinfo():
385 if full or disco.hasinfo():
386 if full:
386 if full:
387 ui.note(_("sampling from both directions\n"))
387 ui.note(_("sampling from both directions\n"))
388 else:
388 else:
389 ui.debug("taking initial sample\n")
389 ui.debug("taking initial sample\n")
390 samplefunc = disco.takefullsample
390 samplefunc = disco.takefullsample
391 targetsize = fullsamplesize
391 targetsize = fullsamplesize
392 else:
392 else:
393 # use even cheaper initial sample
393 # use even cheaper initial sample
394 ui.debug("taking quick initial sample\n")
394 ui.debug("taking quick initial sample\n")
395 samplefunc = disco.takequicksample
395 samplefunc = disco.takequicksample
396 targetsize = initialsamplesize
396 targetsize = initialsamplesize
397 sample = samplefunc(ownheads, targetsize)
397 sample = samplefunc(ownheads, targetsize)
398
398
399 roundtrips += 1
399 roundtrips += 1
400 progress.update(roundtrips)
400 progress.update(roundtrips)
401 stats = disco.stats()
401 stats = disco.stats()
402 ui.debug("query %i; still undecided: %i, sample size is: %i\n"
402 ui.debug("query %i; still undecided: %i, sample size is: %i\n"
403 % (roundtrips, stats['undecided'], len(sample)))
403 % (roundtrips, stats['undecided'], len(sample)))
404
404
405 # indices between sample and externalized version must match
405 # indices between sample and externalized version must match
406 sample = list(sample)
406 sample = list(sample)
407
407
408 with remote.commandexecutor() as e:
408 with remote.commandexecutor() as e:
409 yesno = e.callcommand('known', {
409 yesno = e.callcommand('known', {
410 'nodes': [clnode(r) for r in sample],
410 'nodes': [clnode(r) for r in sample],
411 }).result()
411 }).result()
412
412
413 full = True
413 full = True
414
414
415 disco.addinfo(zip(sample, yesno))
415 disco.addinfo(zip(sample, yesno))
416
416
417 result = disco.commonheads()
417 result = disco.commonheads()
418 elapsed = util.timer() - start
418 elapsed = util.timer() - start
419 progress.complete()
419 progress.complete()
420 ui.debug("%d total queries in %.4fs\n" % (roundtrips, elapsed))
420 ui.debug("%d total queries in %.4fs\n" % (roundtrips, elapsed))
421 msg = ('found %d common and %d unknown server heads,'
421 msg = ('found %d common and %d unknown server heads,'
422 ' %d roundtrips in %.4fs\n')
422 ' %d roundtrips in %.4fs\n')
423 missing = set(result) - set(knownsrvheads)
423 missing = set(result) - set(knownsrvheads)
424 ui.log('discovery', msg, len(result), len(missing), roundtrips,
424 ui.log('discovery', msg, len(result), len(missing), roundtrips,
425 elapsed)
425 elapsed)
426
426
427 if not result and srvheadhashes != [nullid]:
427 if not result and srvheadhashes != [nullid]:
428 if abortwhenunrelated:
428 if abortwhenunrelated:
429 raise error.Abort(_("repository is unrelated"))
429 raise error.Abort(_("repository is unrelated"))
430 else:
430 else:
431 ui.warn(_("warning: repository is unrelated\n"))
431 ui.warn(_("warning: repository is unrelated\n"))
432 return ({nullid}, True, srvheadhashes,)
432 return ({nullid}, True, srvheadhashes,)
433
433
434 anyincoming = (srvheadhashes != [nullid])
434 anyincoming = (srvheadhashes != [nullid])
435 result = {clnode(r) for r in result}
435 result = {clnode(r) for r in result}
436 return result, anyincoming, srvheadhashes
436 return result, anyincoming, srvheadhashes
General Comments 0
You need to be logged in to leave comments. Login now