a &0_g @s@ddlmZddlZddlmZmZmZmZddlm Z m Z m Z m Z m Z ddlmZmZe jrddlmZmZmZmZmZmZmZmZmZeeeeeeeeeef sJejZejZejZej Z Gdd d e!Z"d d Z#d d Z$Gddde!Z%Gddde%Z&dZ'de'Z(de'Z)dZ*ee*Z+dZ,dZ-dZ.Gddde!Z/dS))absolute_importN)binhexnullidnullrev)encodingerrorpycompatscmutilutil) repoviewutil stringutil) AnyCallableDictIterableListOptionalSetTupleUnionc@s8eZdZdZddZddZddZdd Zd d Zd S) BranchMapCachez8mapping of filtered views of repo with their branchcachecCs i|_dSN) _per_filterselfr5/usr/lib/python3/dist-packages/mercurial/branchmap.py__init__9szBranchMapCache.__init__cCs|||j|jSr) updatecacher filternamerreporrr __getitem__<s zBranchMapCache.__getitem__cs|j}|j}|j|dus*|s4t|g}durt|}|dur||}|| |jj |j }| fdd|Dnt| |j j dd|r|||sJ||j|j<dS)zWz-BranchMapCache.updatecache..r)start) changelogr!rgetvalidfor branchcachefromfile subsettablefilteredcopyZ filteredrevsextendrevsr%update)rr#clr!r6Z subsetnameZsubsetZ extrarevsrr(rr @s&      zBranchMapCache.updatecachecs|j}|j|j}g}t}t|D]8}||7}|D]&}|} || \} } | r6||q6q&|rtfdd|D} t|||  | |d} dD]2}| |}| |r| |j |<| |dSqdS)zReplace the branchmap cache for a repo with a branch mapping. This is likely only called during clone with a branch map from a remote. c3s|]}t|VqdSr)intr&nodeZclrevrrr*xr+z)BranchMapCache.replace..) closednodes)sbases immutablesservedN)r-rev branchinfosetr itervaluesaddmaxr0r;r3r/rwrite)rr#Zremotebranchmapr8Z clbranchinfoZrbheadsclosedbheadshr'bcZrtiprevcache candidateZrviewrr<rreplacecs4       zBranchMapCache.replacecCs|jdSr)rclearrrrrrMszBranchMapCache.clearN) __name__ __module__ __qualname____doc__rr$r rLrMrrrrr6s #&rcCstdtt|dS)zK raises ValueError when branchcache found a node which does not exists znode %s does not existN) ValueErrorr Zsysstrrr;rrr _unknownnodesrTcCs|jdurd|jSdSdS)Nsbranch cache (%s)s branch cacher!)r#rrr_branchcachedescs  rVc@seZdZdZdeedddfddZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZeZddZeddZddZeddZddZd d!Zd"d#Zd$d%Zd3d'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2ZdS)4r0a/A dict like object that hold branches heads cache. This cache is used to avoid costly computations to determine all the branch heads of a repo. The cache is serialized on disk in the following format: [optional filtered repo hex hash] ... The first line is used to check if the cache is still valid. If the branch cache is for a filtered repo view, an optional third hash is included that hashes the hashes of all filtered revisions. The open/closed state is represented by a single letter 'o' or 'c'. This field can be used to avoid changelog reads when determining if a branch head closes a branch or not. rNcCs`||_||_||_|dur$t|_n||_t||_d|_t|_||_ |j dur\dd|_ dS)z hasnode is a function which can be used to verify whether changelog has a given node or not. If it's not provided, we assume that every node we have exists in changelog NFcSsdS)NTr)xrrrr+z&branchcache.__init__..) tipnoder% filteredhashr@ _closednodesdict_entries_closedverified_verifiedbranches_hasnode)rentriesrYr%rZr=hasnoderrrrs    zbranchcache.__init__cCs2|jr dS|jD]}||st|qd|_dS)z! verify the closed nodes we have NT)r^r[r`rT)rr;rrr _verifycloseds    zbranchcache._verifyclosedcCsJ||jvs||jvrdS|j|D]}||s"t|q"|j|dS)z) verify head nodes for the given branch. N)r]r_r`rTrB)rbranchnrrr _verifybranchs   zbranchcache._verifybranchcCs,t|j|j}|D]}||qdS)z$ verifies nodes of all the branches N)r@r]keysr_rf)rZneedverificationrHrrr _verifyallszbranchcache._verifyallcCs t|jSr)iterr]rrrr__iter__szbranchcache.__iter__cCs||j|<dSr)r])rkeyvaluerrr __setitem__szbranchcache.__setitem__cCs|||j|Srrfr]rrkrrrr$s zbranchcache.__getitem__cCs||||jvSrrnrorrr __contains__s zbranchcache.__contains__ccs.t|jD]\}}||||fVq dSr)r iteritemsr]rf)rkvrrrrqs zbranchcache.iteritemscCs||||jvS)z4 checks whether a branch of this name exists or not rn)rlabelrrr hasbranchs zbranchcache.hasbranchc CsPd}z4z|||}t|}t|ddd}|dd\}}t|t|}}d}|jj }t |dkr~t|d}|||||d} | |st d| ||WnzttfyYW|r|dSty(} z<|jjrd} |j| t|t| fd} WYd} ~ n d} ~ 00W|rL|n|rJ|0| S)N  )rYr%rZrbz tip differssinvalid %s: %s )cachevfs _filenamerinextrstripsplitrr9r-rblenr/rRloadIOErrorOSErrorclose ExceptionuiZ debugflagdebugrVr Zbytestr) clsr#flineitercachekeyZlastZlrevrZrbr)instmsgrrrr1sV       zbranchcache.fromfilecCs~|D]t}|d}|sq|dd\}}}|dvr:tdt|}t|}|j|g ||dkr|j |qdS)z\ fully loads the branchcache by reading from the file using the line iterator passedrvrwrxsoczinvalid branch statecN) r|r}rRrtolocalstriprr] setdefaultappendr[rB)rr#rliner;statertrrrr2s zbranchcache.loadcCsd}|jrd||jf}|S)z7name of a branchcache file for a given repo or repoviewsbranch2s%s-%srU)r#filenamerrrrzBszbranchcache._filenamecCsDz*|j|j|jko(|jt||jkWSty>YdS0dS)zIs the cache content valid regarding a repo - False when cached tipnode is unknown or if we detect a strip. - True when cache is up to date or a subset of current repo.FN)rYr-r;r%rZr IndexErrorr"rrrr/Js  zbranchcache.validforcCs8|d}d}t|D]}||jvr|}d}q0q||fS)zhReturn tuple with last open head in heads and false, otherwise return last closed head and true.TF)reversedr[)rheadsZtiprErGrrr _branchtipVs  zbranchcache._branchtipcCs|||dS)zReturn the tipmost open head on branch head, otherwise return the tipmost closed head on branch. Raise KeyError for unknown branch.r)r)rrdrrr branchtipbszbranchcache.branchtipcsfdd|DS)Nc3s|]}|jvr|VqdSr)r[)r&rerrrr*ir+z'branchcache.iteropen..r)rnodesrrriteropenhszbranchcache.iteropenFcCs*|||j|}|s&t||}|Sr)rfr]listr)rrdrErrrr branchheadsks   zbranchcache.branchheadsccs,t|D]\}}||f||Vq dSr)r rqr)rbnrrrr iterbranchesrszbranchcache.iterbranchescCs|t|jS)z returns all the heads )rhr rAr]rrrr iterheadsvszbranchcache.iterheadscCst||j|j|j|j|jS)z-return an deep copy of the branchcache object)typer]rYr%rZr[rrrrr4{szbranchcache.copyc Cs2z|j||ddd}t|jd|jg}|jdurF|t|j|d|dd}t t |j D]P\}}t |}|D]8}|d7}||jvrd }nd }|d t|||fqqn||jd d t|t|j |WnDtttjfy,} z"|jdt| WYd} ~ n d} ~ 00dS)NwT)Z atomictemps%drwrvrrros %s %s %s branchcaches%wrote %s with %d labels and %d nodes s couldn't write branch cache: %s )ryrzrrYr%rZrrDjoinsortedr rqr]r fromlocalr[rrlogrVr~rrr Abortrr forcebytestr) rr#rrZ nodecountrtrr;rrrrrrDs:   zbranchcache.writecst}|ji}|j}|D]8}||\}}||g||r |j |q t } |j } t |D]\}} |j|g} fdd| D} | | | | }|rt|}t | |}| |8} t| }fdd|D||<|d}|| krv|} qv| |j kr&| |_ | |_||st|_t|_ |D]:}tfdd|D}||j krF ||_||_ qFt||j |_t|}|jdd t||||d S) zGiven a branchhead cache, self, that may have extra nodes or be missing heads, and a generator of nodes that are strictly a superset of heads missing, this function updates self to be correct. csh|]}|qSrr>r:r8rr r+z%branchcache.update..csg|]}|qSrrS)r&r>rrr r+z&branchcache.update..rc3s|]}|VqdSrrr:rrrr*r+z%branchcache.update..rsupdated %s in %.4f seconds N) r Ztimerr-revbranchcacher?rrr[rBr;r@Zheadrevsr%r rqr]r7min ancestorsrrYr/rrrrCr rZrrrVrD)rr#ZrevgenZ starttimeZ newbranchesZ getbranchinfor'rdZ closesbranchZ topoheadsZntiprevZ newheadrevsrFZbheadsetZ uncertainZfloorrevrZ bheadrevsr%rZdurationrrrr7sZ            zbranchcache.update)F) rNrOrPrQrrrrcrfrhrjrmr$rprqitemsru classmethodr1r staticmethodrzr/rrrrrrr4rDr7rrrrr0sB    -      r0c@seZdZdZddZdS)remotebranchcachez@Branchmap info for a remote connection, should not write locallycCsdSrrr"rrrrDszremotebranchcache.writeN)rNrOrPrQrDrrrrrsrs-v1s rbc-namessrbc-revss>4sIilc@sjeZdZdZdddZddZejddZd d Z d d Z d dZ ddZ dddZ ddZddZdS)raPersistent cache, mapping from revision number to branch name and close. This is a low level cache, independent of filtering. Branch names are stored in rbc-names in internal encoding separated by 0. rbc-names is append-only, and each branch name is only stored once and will thus have a unique index. The branch info for each revision is stored in rbc-revs as constant size records. The whole file is read into memory, but it is only 'parsed' on demand. The file is usually append-only but will be truncated if repo modification is detected. The record for each revision contains the first 4 bytes of the corresponding node hash, and the record is only used if it still matches. Even a completely trashed rbc-revs fill thus still give the right result while converging towards full recovery ... assuming no incorrectly matching node hashes. The record also contains 4 bytes where 31 bits contains the index of the branch and the last bit indicate that it is a branch close commit. The usage pattern for rbc-revs is thus somewhat similar to 00changelog.i and will grow with it but be 1/8th of its size. Tc Cs"|jdusJ||_g|_t|_d|_z4|jt}t ||_|rZdd| dD|_Wn"t t fy~|rz|j |_Yn0|jrz|jt}||jdd<Wn>t t fy}z"|jdt|WYd}~n d}~00tt |jtt |j|_|jdkrg|_t |j|_dS)NrcSsg|]}t|qSr)rr)r&rrrrr%sz+revbranchcache.__init__..s(couldn't read revision branch cache: %s )r!_repo_names bytearray_rbcrevs _rbcsnameslenryread _rbcnamesr~r}rr _branchinfor?rrrrr _rbcrecsizer- _rbcrevslen_rbcnamescount)rr#readonlyZbndatadatarrrrrs>     zrevbranchcache.__init__cCsFd|_|jdd=d|_t|jj|_t|jt|_ t |ddS)Nrs _namesreverse) rrrr~rr-rrrrr Zclearcachedpropertyrrrr_clear?s  zrevbranchcache._clearcCsddt|jDS)NcSsi|]\}}||qSrr)r&r'rHrrr Ir+z0revbranchcache._namesreverse..) enumeraterrrrr _namesreverseGszrevbranchcache._namesreversec Cs |jj}|t}|tkr"||St|j|tkr>||S||dt }t t t |j|\}}t|t@}|r|tM}|dkrnx||krz|j||fWSty|jjd|Yn0n4|jjd||t}|j|d=t|j||_||S)zWReturn branch name and close flag for rev, using and updating persistent cache.NssRreferenced branch names not found - rebuilding revision branch cache from scratch sPhistory modification detected - truncating revision branch cache to revision %d )rr-rrr?r~rrr; _rbcnodelen unpack_from _rbcrecfmtr bufferbool _rbccloseflag_rbcbranchidxmaskrrrrrrr) rr>r- rbcrevidxreponodeZ cachenode branchidxrtruncaterrrr?Ks@     zrevbranchcache.branchinfocCsx|jj}||\}}||jvr,|j|}n t|j}|j|||j|<||}|rb|tO}| |||||fS)z7Retrieve branch info from changelog and update _rbcrevs) rr-r?rr~rrr;r _setcachedata)rr>r-rHrrrrrrrzs      zrevbranchcache._branchinfocCsd||jvr|j|}n t|j}|j|||j|<|rB|tO}||||dt|vr`|`dS)z%add new data information to the cacher?N)rr~rrrrvarsr?)rrdr>r;rrrrrsetdatas      zrevbranchcache.setdatacCs|tkr dS|t}t|j|tkrL|jdt|jjtt|jtt|j|||t |j ||_ |j }|r| d|j dS)z:Writes the node's branch data to the in-memory cache data.Nrswrite-revbranchcache)rrr~rr5rr- pack_intorrrZcurrenttransactionZ addfinalizerD)rr>r;rrtrrrrrs zrevbranchcache._setcachedataNc Cs|j}d}d}zzj|jt|jkr<|jdd}d}|||jt}|t|jkrxd}|durl|jdd}| ||WnJt t t j t jfy}z&|jd|t|fWYd}~n d}~00W|dur|n|dur|0dS)z!Save branch cache if it is dirty.Nr+F)waits namess+couldn't write revision branch cache%s: %s )rrr~rwlock _writenamesrrr _writerevsrrr rZ LockErrorrrrrrelease)rrr#rstepr,rrrrrDs0      zrevbranchcache.writecCs|jdkrV|jtd}||jkr2|dn$||j dtd|_d|_ |jdkr~|jj t dd|jtd}|d dd |j|jd D||_|t|j|_d S) z. write the new branch names to revbranchcache rabrs%s changed - rewriting it T)Z ignoremissingswbcss|]}t|VqdSr)rr)r&rHrrrr*sz-revbranchcache._writenames..N)rryopenrtellrrDrrrrZ unlinkpathrrrr~)rr#rrrrrs&     zrevbranchcache._writenamescCstt|jt|jt}|jtdx}||krv|j dt|f| |||krnd}| || |t}| |j||Wdn1s0Y||_ dS)z& write the new revs to revbranchcache rstruncating cache/%s to %d rN)rr~r-rrryrrrrseekrrDr)rr#r,r6rendrrrrs     2zrevbranchcache._writerevs)T)N)rNrOrPrQrrr Z propertycacherr?rrrrDrrrrrrrs $ / r)0Z __future__rZstructr;rrrrrr r r r Zutilsr r TYPE_CHECKINGtypingrrrrrrrrranyr2ZcalcsizerrobjectrrTrVr0rZ _rbcversionrrrrrrrrrrrrs: , WX