ó
ÛXc@@s§dZd
dl
mZ
d
dlZd
dlZddlmZ
ddlmZm	Z	
ddl
mZmZ
d
d„
Z
d	„Zd
„Zd„Zdd
ed„ZdS(s;
Algorithm works in the following way. You have two repository: local and
remote. They both contains a DAG of changelists.

The goal of the discovery protocol is to find one set of node *common*,
the set of nodes shared by local and remote.

One of the issue with the original protocol was latency, it could
potentially require lots of roundtrips to discover that the local repo was a
subset of remote (which is a very common case, you usually have few changes
compared to upstream, while upstream probably had lots of development).

The new protocol only requires one interface for the remote repo: `known()`,
which given a set of changelists tells you if they are present in the DAG.

The algorithm then works as follow:

 - We will be using three sets, `common`, `missing`, `unknown`. Originally
 all nodes are in `unknown`.
 - Take a sample from `unknown`, call `remote.known(sample)`
   - For each node that remote knows, move it and all its ancestors to `common`
   - For each node that remote doesn't know, move it and all its descendants
   to `missing`
 - Iterate until `unknown` is empty

There are a couple optimizations, first is instead of starting with a random
sample of missing, start by sending all heads, in the case where the local
repo is a subset, you computed the answer in one round trip.

Then you can do something similar to the bisecting strategy used when
finding faulty changesets. Instead of random samples, you can try picking
nodes that will maximize the number of nodes that will be
classified with it (since all ancestors or descendants will be marked as well).
i(
tabsolute_importNi
(
t
_(tnullidtnullrev(tdagutilterrorcC@s8
|
r|j|
ƒ
}n|j
ƒ}i}tj|ƒ
}tƒ}d
}xé|r3
|jƒ}	|	|kroqKn|j|	d
ƒ}
|
|krš|d9}n|
|krÒ|j|	ƒ

|rÒt|ƒ
|krÒdSn|j|	ƒ

xN|j	|	ƒ
D]=}|
s
||
krï|j||
d
ƒ
|j
|ƒ

qïqïWqKWdS(s'update an existing sample to match the expected size

    The sample is updated with nodes exponentially distant from each head of the
    <nodes> set. (H~1, H~2, H~4, H~8, etc).

    If a target size is specified, the sampling will stop once this size is
    reached. Otherwise sampling will happen until roots of the <nodes> set are
    reached.

    :dag: a dag object from dagutil
    :nodes:  set of nodes we want to discover (if None, assume the whole dag)
    :sample: a sample to update
    :quicksamplesize: optional target size of the samplei
iN(theadsetofconnectedstheadstcollectionstdequetsettpopleftt
setdefaulttaddtlentparentstappend(tdagtnodestsampletquicksamplesizeRtdisttvisittseentfactortcurrt
dt
p((s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pyt
_updatesample:s.



	

	

















cC@sH|j|
ƒ
}|t
|ƒ
k
r.t||ƒSt|d|d
|ƒ

|S(sðtakes a quick sample of size <size>

    It is meant for initial sampling and focuses on querying heads and close
    ancestors of heads.

    :dag: a dag object
    :nodes: set of nodes to discover
    :size: the maximum size of the sampleRN(RRt_limitsampleRtNone(RRtsizeR((s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pyt_takequicksamplebs
	




cC@sœ|j|
ƒ
}t
||
|ƒ
t
|jƒ|
|ƒ
|sAt‚
t||ƒ}t|ƒ
|kr˜|t|ƒ
}|jtjt	|
|ƒ
|ƒƒ

n|S(
N(
RRtinversetAssertionErrorRRtupdatetrandomRtlist(RRRRtmore((s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pyt_takefullsampleqs





&
cC@s1t|ƒ
|
kr-t
tj||
ƒƒ
}n|S(
s;return a random subset of sample of at most desiredlen item(RR
R$R(Rt
desiredlen((s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pyR~s

idiÈc@s—d
}|
j}t
j|ƒ
}|jdƒ

|d7}|jƒ}	t|	|ƒ}
t|
ƒ
}
|jƒ}|jƒ
|j|j	|
ƒ
ƒ

|j
ƒ
|jƒ\}‰|jƒt
krå|t
g
krÕt
g
t|fSt
g
tgfS|jtdƒ
ƒ

|j|dtƒ

}
t|
ƒ
t|ƒ
kr?
|jdƒ

|t|fS|
r’
t|	ƒ
|k
r’
tˆƒ
r’
|jtdƒ
ƒ

|j	|	ƒ
}|t|fS|j|
ƒ
}t‡f
d†t|
ƒ
Dƒ
ƒ
}|j|ƒ

t|j|	ƒ
ƒ
}tƒ}t}xØ
|rÎ|
r[gt|
ƒ
D]\}}ˆ|s|^q}|j|j||ƒƒ

|j|ƒ

n|sePn|sw|jƒr¯|r“|jtd	ƒ
ƒ

n
|jd
ƒ

t}|}n|jdƒ

t }|}t|ƒ
|krét|ƒ
}
n!||||ƒ}
t|
|ƒ}
|d7}|j!tdƒ
|d
tdƒ
ƒ

|jd|t|ƒ
t|
ƒ
fƒ

t|
ƒ
}
|j|j	|
ƒ
ƒ
‰t}|
r÷
t‡f
d†t|
ƒ
Dƒ
ƒ
}|j|ƒ

|j"|ƒ

q÷
q÷
W|j#|j$ƒ
}|j%t&ƒ

|j!tdƒ
dƒ
|jd|ƒ

|rr|t
g
krr|rIt(j)tdƒ
ƒ
‚
n|j*tdƒ
ƒ

tt
g
ƒ
t|fS|t
g
k}|j	|ƒ
||fS(slReturn a tuple (common, anyincoming, remoteheads) used to identify
    missing nodes from or in remote.
    isquery 1; heads
i
ssearching for changes
t
filterunknownsall remote heads known locally
sall local heads known remotely
c
3@s%|]\}
}ˆ|
r|V
qdS(
N((t.0t
it
n(
tyesno(s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pys	<genexpr>µsssampling from both directions
staking initial sample
staking quick initial sample
t	searchingtunittqueriess2query %i; still undecided: %i, sample size is: %i
c
3@s%|]\}
}ˆ|
r|V
qdS(
N((R*R+R,(
R-(s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pys	<genexpr>äss%d total queries
srepository is unrelateds!warning: repository is unrelated
N(+t	changelogRt	revlogdagtdebugRRR%t	iterbatchtknowntexternalizealltsubmittresultsttipRtTruetFalsetstatusR
tinternalizeallRtalltnotetincrementalmissingrevsR
t	enumeratetaddbasestmissingancestorsR#t
descendantsettdifference_updatethasbasesR'R tprogresstremoveancestorsfromRtbasestdiscardRRRtAborttwarn(tuitlocaltremotetinitialsamplesizetfullsamplesizetabortwhenunrelatedt
roundtripstclRtownheadsRtbatcht
srvheadhashestsrvheadst
ownheadhashestcommontcommoninsamplet	undecidedtmissingtfullR+R,tmissinginsamplet
samplefunct
targetsizetresulttanyincoming((
R-s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pytfindcommonheads„s”
	




















$




"

	
	
/






	







"
	



"









(t__doc__t
__future__RRR$ti18nR
tnodeRRtRRRR R'RR:Rd(((s:/usr/lib/python2.7/dist-packages/mercurial/setdiscovery.pyt<module>)s

(