|
Server : Apache System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64 User : dh_edsupp ( 6597262) PHP Version : 8.2.26 Disable Function : NONE Directory : /lib/python3/dist-packages/mercurial/__pycache__/ |
Upload File : |
o
�]LbW� � @ s� d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z m
Z
mZmZmZmZ ddlmZ ddlmZ ddlmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ dd l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 dd
l4m5Z5 dd l6m7Z7m8Z8m9Z9m:Z:m;Z;mZm<Z<m=Z=m>Z> dd l?m@Z@m>ZA dd
l<mBZCmDZEmFZFmGZHmIZImJZJmKZKmLZM ddlNmOZOmPZP e# e$ e& e e e e( e) e* e% e' e2 e. e1 e/ e- e0 e3 e;�Qd�ZRe;�Sd�ZTe;�Sd�ZUe;�Sd�ZVe
jWZXdZYdd� ZZdd� Z[dd� Z\eZe[e\fZ]dd� Z^eVdu�p e>�_eRd �Z`eA�ae@jb�e5jcd d �G d d � d ed���ZeeA�ae@jf�e5jcd d!�G d"d#� d#ed���Zgd$d%� Zhd&d'� Zid(d)� Zje>�_eRd*��rad+d,� ZkndZkd-d.� Zld/Zmed0�ZnG d1d� ded�ZodS )2z�Storage back-end for Mercurial.
This provides efficient delta storage with O(1) retrieve and append
and O(changes) merge between branches.
� )�absolute_importN� )�bin�hex�nullrev�sha1nodeconstants�short�wdirrev)�_)�getattr)� ALL_KINDS� CHANGELOGV2�COMP_MODE_DEFAULT�COMP_MODE_INLINE�COMP_MODE_PLAIN�
ENTRY_RANK�FEATURES_BY_VERSION�FLAG_GENERALDELTA�FLAG_INLINE_DATA� INDEX_HEADER�KIND_CHANGELOG� RANK_UNKNOWN�REVLOGV0�REVLOGV1�REVLOGV1_FLAGS�REVLOGV2�REVLOGV2_FLAGS�REVLOG_DEFAULT_FLAGS�REVLOG_DEFAULT_FORMAT�REVLOG_DEFAULT_VERSION�SUPPORTED_FLAGS)�REVIDX_DEFAULT_FLAGS�REVIDX_ELLIPSIS�REVIDX_EXTSTORED�REVIDX_FLAGS_ORDER�REVIDX_HASCOPIESINFO�REVIDX_ISCENSORED� REVIDX_RAWTEXT_CHANGING_FLAGS)�attr) �ancestor�dagop�error�mdiff�policy�pycompat� revlogutils�templatefilters�util)�
repositoryr1 )�deltas�docket�flagutil�nodemap�randomaccessfile�revlogv0�rewrite�sidedata)� storageutil�
stringutil�parsersr) r* �revlogi c C � |dfS �NF� ��rl�textrA rA �2/usr/lib/python3/dist-packages/mercurial/revlog.py�ellipsisreadprocessor� � rF c C r? r@ rA rB rA rA rE �ellipsiswriteprocessor� rG rH c C � dS r@ rA rB rA rA rE �ellipsisrawprocessor� s rJ c C s$ |r |d � |� dS | �|� dS )z}Verify the integrity of the given revlog ``node`` while providing a hook
point for extensions to influence the operation.� skipreadN)�add�revision)rC � skipflags�state�noderA rA rE �_verify_revision� s rQ �BaseIndexObjectT)�slotsc @ sh e Zd Ze�� Ze�� Ze�� Ze�� Ze�� Z e�� Z
e�� Z e�� Z e�� Z
e�� Zejdd�ZdS )�revlogrevisiondeltaN��default)�__name__�
__module__� __qualname__r( �ibrP �p1node�p2node�basenode�flags�baserevisionsizerM �deltar: �protocol_flags�linknoderA rA rA rE rT � s rT )�frozenc @ s0 e Zd Zejdd�Zejdd�Zejdd�ZdS )�
revlogproblemNrU )rW rX rY r( rZ �warningr+ rP rA rA rA rE rd � s rd c C � t �| |�\}}||fS �N)r= � parse_index2��data�inline�index�cacherA rA rE �parse_index_v1� s rn c C � t j| |td�\}}||fS �N)�format)r= rh r ri rA rA rE �parse_index_v2� � rr c C ro rp )r= rh r
ri rA rA rE �parse_index_cl_v2� rs rt �parse_index_devel_nodemapc C rf rg )r= ru ri rA rA rE �parse_index_v1_nodemap� s rv c C s t | |�\}}t�|�|fS rg )rn �
rustrevlog�
MixedIndexri rA rA rE �parse_index_v1_mixed� s ry i���sN cannot read from revlog %s; expected %d bytes from offset %d, data size is %dc @ s8 e Zd ZdZejZ d�dd�Zdd� Zd�dd �Z d�d
d �Z
e j d d
� �Z
e j dd� �Zdd� Ze j dd� �Ze j dd� �Zdd� Zdd� Zdd� Zd�d d �Zejd d � �Zd!d"� Zd#d$� Zd%d&� Zd'd(� Z d)d*� Z d�d,d-�Z d.d/� Z d0d1� Z d2d3� Z!d4d5� Z"d6d7� Z#d8d9� Z$d:d;� Z%d<d=� Z&d>d?� Z'd@dA� Z(dBdC� Z)dDdE� Z*dFdG� Z+dHdI� Z,dJdK� Z-dLdM� Z.e.Z/dNdO� Z0dPdQ� Z1dRdS� Z2dTdU� Z3dVdW� Z4d�dXdY�Z5d�dZd[�Z6d\d]� Z7d�d^d_�Z8d�d`da�Z9d�dbdc�Z:d�ddde�Z;d�dfdg�Z<d�dhdi�Z=djdk� Z>dldm� Z?d�dndo�Z@dpdq� ZAdrds� ZBdtdu� ZCdvdw� ZDdxdy� ZEd�dzd{�ZFd|d}� ZGd~d� ZHd�d�� ZId�d�� ZJd�d�d��ZKd�d�� ZLd�d�d��ZMd�d�d��ZNd�d�d��ZOd�d�� ZPd�d�� ZQd�d�� ZRd�d�� ZSd�d�d��ZTd�d�d��ZUd�d�d��ZVd�d�d��ZWd�d�� ZXd�d�d��ZYd�d�� ZZd�d�d��Z[d�d�� Z\d�d�� Z]ejd�d�� �Z^ejd�d�� �Z_d�d�� Z`ddeaddfd�d��Zb d�d�d��Zcd�d�� Zdd�d�� Ze d�d�d��Zfd�d�� Zgd�d�� Zh d�d�d��Zid�d Zjd�dĄ Zkd�dƄ Zld�dȄ Zmd�dʄ Znd�d̄ Zodddepjqdfd�d΄Zrd�Zsd�Ztd�Zud�Zvh dӣZwdetddfd�dՄZxd�dׄ Zyd�d�dڄZzd�d܄ Z{ d�d�dބZ|d�d� Z}dS )�r> ak
the underlying revision storage object
A revlog consists of two parts, an index and the revision data.
The index is a file with a fixed record size containing
information on each revision, including its nodeid (hash), the
nodeids of its parents, the position and offset of its data within
the data file, and the revision it's based on. Finally, each entry
contains a linkrev entry that can serve as a pointer to external
data.
The revision data itself is a linear collection of data chunks.
Each chunk represents a revision and is usually represented as a
delta against the previous chunk. To bound lookup time, runs of
deltas are limited to about 2 times the length of the original
version data. This makes retrieval of a version proportional to
its size, or O(1) relative to the number of revisions.
Both pieces of the revlog are written to in an append-only
fashion, which means we never need to rewrite a file to insert or
remove data, and can use some simple techniques to avoid the need
for locking while reading.
If checkambig, indexfile is opened with checkambig=True at
writing, to avoid file stat ambiguity.
If mmaplargeindex is True, and an mmapindexthreshold is set, the
index will be mmapped rather than read if it is larger than the
configured threshold.
If censorable is True, the revlog can have censored revisions.
If `upperboundcomp` is not None, this is the expected maximal gain from
compression for the data content.
`concurrencychecker` is an optional function that receives 3 arguments: a
file handle, a filename, and an expected position. It should check whether
the current position in the file handle is valid, and log/warn/fail (by
raising).
See mercurial/revlogutils/contants.py for details about the content of an
index entry.
NFc C s || _ || _d| _d| _d| _d| _d| _|| _| | _|| _ | r&t
� | �| _|d t v s.J �t
|�dks6J �|| _|| _|| _|| _d| _t�d�| _d| _d| _d| _d| _d| _d| _d| _ i | _ d| _ i | _ d | _ d
| _!d
| _"d
| _#d | _$d | _%t&t'j(�| _)d| _*d| _+| �,� |
| _-dS )
aJ
create a revlog object
opener is a function that abstracts the file opening operation
and can be used to implement COW semantics or the like.
`target`: a (KIND, ID) tuple that identify the content stored in
this revlog. It help the rest of the code to understand what the revlog
is about without having to resort to heuristic and index filename
analysis. Note: that this must be reliably be set by normal code, but
that test, debug, or performance measurement code might not set this to
accurate value.
Nr � �d )r � i Ts zlib���Fg �?i ).�upperboundcomp�radix� _docket_file�
_indexfile� _datafile�
_sidedatafile�
_nodemap_file�postfix� _trypending�opener� nodemaputil�get_nodemap_filer �len�target� _checkambig�_mmaplargeindex� _censorable�_revisioncacher1 � lrucachedict�_chainbasecache� _chunkcache�_chunkcachesize� _maxchainlen�_deltabothparentsrl �_docket�_nodemap_docket�_pcache� _compengine�_compengineopts�_maxdeltachainspan�_withsparseread�
_sparserevlog� hassidedata�_srdensitythreshold�
_srmingapsize�dictr5 �flagprocessors�_flagprocessors�_writinghandles�
_adding_group�
_loadindex�_concurrencychecker) �selfr� r� r r� �
checkambig�mmaplargeindex�
censorabler~ �persistentnodemap�concurrencychecker�
trypendingrA rA rE �__init__! sR
zrevlog.__init__c C s" d}| j j}d|v r| jtkrt}n#d|v rt}n d|v r*ttB }d|v r)|tO }n d| j jv r3t }nt
}d|v r>|d | _ d|v rG|d | _ d |v rP|d | _
t|�d
d ��| _d | _| jrht|�d
d ��| _d|v rq|d | _d|v r||d | jd< d|v r�|d | jd< d|v r�|d | _| jr�d|v r�|d }t|�dd ��| _t|�dd ��}| jp�|| _d|v r�|d | _d|v r�|d | _|�d�r�t| jt < t � |�di ��D ] \}}t � ||| j� q�| j dkr�t!�"t#d�| j ��| j | j d @ �rt!�"t#d �| j ��|�d d �}|||fS ) a process options (from above/config) to setup associated default revlog mode
These values might be affected when actually reading on disk information.
The relevant values are returned for use in _loadindex().
* newversionflags:
version header to use if we need to create a new revlog
* mmapindexthreshold:
minimal index size for start to use mmap
* force_nodemap:
force the usage of a "development" version of the nodemap code
Ns changelogv2s revlogv2s revlogv1� generaldeltas revlogv0s chunkcachesizes maxchainlens deltabothparentss lazydeltaTFs
lazydeltabases
compengines
zlib.levels
zstd.levels maxdeltachainspans mmapindexthresholds
sparse-revlogs with-sparse-reads sparse-read-density-thresholds sparse-read-min-gap-sizes enableellipsiss flagprocessorsr s0 revlog chunk cache size %r is not greater than 0r s. revlog chunk cache size %r is not a power of 2s devel-force-nodemap)$r� �options� revlog_kindr r
r r r r r r r� r� r� �bool�get�
_lazydelta�_lazydeltabaser� r� r� r� r� r� r� r� �ellipsisprocessorr� r" r. � iteritemsr5 �insertflagprocessorr+ � RevlogErrorr
)r� �mmapindexthreshold�opts�
new_header�withsparseread�flag� processor�
force_nodemaprA rA rE �
_init_optsy sz �
�
����
zrevlog._init_optsc
C s zk| � |��[}|durD| j �|�j}||krD|dur t||�}|du r3t�t�|��W d � W S t�t�||��W d � W S |du rT|�� W d � W S |�|�W d � W S 1 sdw Y W dS ty� } z|j t j
krz� W Y d}~dS d}~ww )zbreturn a file content with or without mmap
If the file is missing return the empty stringNr| ) r� �fstat�st_size�minr1 �buffer�mmapread�read�IOError�errno�ENOENT)r� �filepath�mmap_threshold�size�fp� file_size�instrA rA rE � _get_data� s.
� �
�(� ��zrevlog._get_datac C sj | � � \}}}| jd urd| j| jf }n| jr'| j�d| j �r'd| j }nd| j }|d ur7|| _|| _n�d}d| _| � ||�}t
|�dkrWt � |d d� �d }d| _n|}|d @ | _
|d
@ | _t�| j�}|d u r~td �} | | j| jf; } t�| ��| j
| @ r�td �} | j
d
? }
| |
| j| jf; } t�| ��t| j } | d | j
�| _| d | j
�| _| d | _| d s�|| _|} n|| _| jr�t�| |�| _n
tj | || jd�| _| jd u�r| j� � | _d} | jj }
|
dk�r| j | j||
d�} t
| �|
k �rtd�} | | jt
| �|
f; } t�| ��d| _d| _d | _ | jd u�r-| j� � | _!| j�"� | _#n| jd u �r:d| j | _!n d| j| jf | _!t$| _%| j%j&| _&| j�sRd| _'d| _(| j �o_|�o_t)d u}d}t*d u�rw| j d u�rpd}n| jj+�d�}t,| _-| jt.k�r�t/j0| _-n!| jt1k�r�t2| _-n| jt3k�r�t4| _-n
|�r�t)| _-n|�r�t5| _-zN| �-| | j�}|\}}| j �o�| j d u�o�t6�7|d�}|�r�t8�9| �}|d u�r�|d }t
|d �|j:k�r�|d |j: d |j;k�r�|| _<|j=|� W n t>t?f�y t�td�| j ��w || _@tA�A| j| j�r| jn| j!| jB|�| _CtA�A| j| j#| jB�| _Dt6�Ed�| _Fi | _Gd S ) Ns %s.i.%ss %s.i.as %s.ir| Tr � Fi ��� s! unknown version (%d) in revlog %ss- unknown flags (%#04x) in version %d revlog %s� s inliner� s sidedatas docket)� use_pending)r� s. too few index data for %s: got %d, expected %ds %s.ds %s.d.%ss
rust.index�update_nodemap_data� s index %s is corrupted�� )Hr� r� r r� r� �existsr� r� �
_initemptyr� r� r �unpack�
_format_flags�_format_versionr r� r
�
display_idr+ r� r �_inline�
_generaldeltar� r� �
docketutil�default_docket� parse_docket�index_filepath� index_endr� �
data_filepathr� �sidedata_filepathr� r �
nodeconstants�nullidr� �_storedeltachainsrv rw r� rn � _parse_indexr r8 �parse_index_v0r rr r
rt ry r1 � safehasattrr� �persisted_data�tip_rev�tip_noder� r� �
ValueError�
IndexErrorrl r7 r� � _segmentfile�_segmentfile_sidedatar� �_chaininfocache�_decompressors)r� r4 r� r� r� � entry_point�
entry_data�header�supported_flags�msg� display_flag�features�
index_data�
index_size�
devel_nodemap�use_rust_index�drl �
chunkcache� use_nodemap� nodemap_datarA rA rE r� � s�
�
�
��
�
�
� ����
zrevlog._loadindexc C s
| j d S �Nr )r� �r� rA rA rE r� � s
zrevlog.revlog_kindc C s | j S )z;The public facing "ID" of the revlog that we use in message)r r rA rA rE r� � s zrevlog.display_idc C sr z| j | }W |S ty8 ztj�|�}|�| j�}|| j |< W Y |S ty7 t�t d�t
� |� ��w w )Ns unknown compression type %s) r� �KeyErrorr1 � compengines�forrevlogheader�revlogcompressorr� r+ r� r
�binascii�hexlify)r� �t�
compressor�enginerA rA rE �_get_decompressor� s
� ����zrevlog._get_decompressorc C s t j| j }|�| j�S rg )r1 r
r� r r� )r� r rA rA rE � _compressor� s zrevlog._compressorc C s& | j du rdS | j j}| �|�}|jS )zthe default decompressorN)r� �default_compression_headerr �
decompress)r� r �crA rA rE �
_decompressor� s
zrevlog._decompressorc C s | j | jdd�S )z'file object for the revlog's index file� r��mode)r� r� r rA rA rE �_indexfp� � zrevlog._indexfpc
C s� z%| j | jd| jd�}| jd u r|�dtj� |W S |�| jjtj� |W S t yH } z|j
t
j kr4� | j | jd| jd�W Y d }~S d }~ww )N� r+)r r� r � w+) r� r� r� r� �seek�os�SEEK_ENDr� �SEEK_SETr� r� r� )r� �fr� rA rA rE �__index_write_fp� s"
�
�
���zrevlog.__index_write_fpc C s | j | jd| jdd�S )N� wT)r r� �
atomictemp)r� r� r� r rA rA rE �__index_new_fp� s �zrevlog.__index_new_fpr c C s | j | j|d�S )z&file object for the revlog's data filer )r� r� )r� r rA rA rE �_datafp� r zrevlog._datafpc c sP � | j r | j d V dS | �| j�� }|V W d � dS 1 s!w Y dS )z%file object suitable to read sidedatarz N)r� r� r� )r� r� rA rA rE �_sidedatareadfp� s �"�zrevlog._sidedatareadfpc C s t | j�d S �Nr �r� rl r rA rA rE �tiprev� � z
revlog.tiprevc C s | � | �� �S rg )rP r, r rA rA rE �tip� r- z
revlog.tipc C s d| ko t | �k S S r )r� �r� �revrA rA rE � __contains__� s zrevlog.__contains__c C s
t | j�S rg r+ r rA rA rE �__len__� s
zrevlog.__len__c C s t t�t| ���S rg )�iterr. �xranger� r rA rA rE �__iter__� � zrevlog.__iter__r c C s t jt| �||d�S )z8iterate over all rev in this revlog (from start to stop)��start�stop)r; �iterrevsr� )r� r8 r9 rA rA rE �revs� s z revlog.revsc C s& z| � |� W dS ty Y dS w )NTF)r0 r �r� rP rA rA rE �hasnode� s
�zrevlog.hasnodec C s$ | � |�t@ s| � |�t@ rdS dS )z;whether two revisions (baserev, rev) can be delta-ed or notFT)r^ r' )r� �baserevr0 rA rA rE �candelta� s
�zrevlog.candeltac C s4 | j d ur|d u rt�| � d S t�|| � d S d S rg )r� r� �update_persistent_nodemap�setup_persistent_nodemap�r� � transactionrA rA rE �
update_caches� s
�zrevlog.update_cachesc C s� d | _ | j�� | j�� | j�� i | _d | _| j� � | j
o,| j d uo,t �
| jd�}|rEt�| �}|d urG|d | _| jj|� d S d S d S )Nr� r )r� r� �clearr� � clear_cacher� r� r� rl � clearcachesr� r� r1 r� r� r� r� )r� r r rA rA rE rG s&
� �
�zrevlog.clearcachesc C s` z| j �|�W S ty � tjy/ || jjks"|| jjv r%tj�t� || j
t d���w )N� no node) rl r0 � TypeErrorr+ r� r� �wdirid�wdirfilenodeids�WdirUnsupported� LookupErrorr� r
r< rA rA rE r0 s �z
revlog.revc C s t | j| d d? �S )Nr r� )�intrl r/ rA rA rE r8 * s z revlog.startc C s\ | j | d }|dkr
|S d|kr,| j | }|d dkr$|d |d S |d8 }d|ksdS )N� r � r �rl )r� r0 �
sd_cut_off�erA rA rE �sidedata_cut_off- s
�zrevlog.sidedata_cut_offc C s | j | d d@ S )Nr r� rQ r/ rA rA rE r^ > r6 z revlog.flagsc C � | j | d S r* rQ r/ rA rA rE �lengthA r- z
revlog.lengthc C s | j sdS | j| d S )Nr rP )r� rl r/ rA rA rE �sidedata_lengthD s zrevlog.sidedata_lengthc C s, | j | d }|dkr
|S | �|�}t|�S )z?return the length of the uncompressed text for a given revisionrz r )rl �rawdatar� )r� r0 �lr rA rA rE �rawsizeI s
zrevlog.rawsizec C s4 | � |�}|tjtA @ dkr| �|�S t| �|��S )z=length of non-raw text (processed by a "read" flag processor)r )r^ r5 �REVIDX_KNOWN_FLAGSr" rZ r� rM )r� r0 r^ rA rA rE r� R s
z revlog.sizec C s | j | t }|tkr
dS |S )a� Return the rank of a revision if already known, or None otherwise.
The rank of a revision is the size of the sub-graph it defines as a
head. Equivalently, the rank of a revision `r` is the size of the set
`ancestors(r)`, `r` included.
This method returns the rank retrieved from the revlog in constant
time. It makes no attempt at computing unknown values for versions of
the revlog which do not persist the rank.
N)rl r r )r� r0 �rankrA rA rE � fast_rank\ s zrevlog.fast_rankc C s\ | j �|�}|d ur |S | j}|}|| d }||kr'|}|| d }||ks|| j |< |S )N� )r� r� rl )r� r0 �baserl �iterrevrA rA rE � chainbasel s �
zrevlog.chainbasec C rU )Nr� rQ r/ rA rA rE �linkrev{ r- zrevlog.linkrevc C s> z| j | }W n ty |tkrtj�� w |d |d fS )N� � �rl r� r r+ rL )r� r0 �entryrA rA rE �
parentrevs~ s �zrevlog.parentrevsc C s0 z| j | d W S ty |tkrtj�� w )Nr� re r/ rA rA rE rP � s �z revlog.nodec C s | � |�| �|� S rg )r8 rV r/ rA rA rE �end� � z
revlog.endc C s4 | j }|| �|� }||d d ||d d fS )Nrc r� rd )rl r0 )r� rP �ir rA rA rE �parents� s zrevlog.parentsc C s | � |�d S r )�
_chaininfor/ rA rA rE �chainlen� r- zrevlog.chainlenc C s� | j }||v r || S | j}| j}|}|| }d}d}||d krU|d7 }||d 7 }|r2|d }n|d8 }||v rK|| } || d 7 }|| d 7 }n|| }||d ks!||d 7 }||f}
|
||< |
S )Nr r^ r )r� rl r� ) r� r0 �chaininfocacherl � generaldeltar` rS �clen�compresseddeltalenr �rrA rA rE rl � s4
� zrevlog._chaininfoc C s� z
| j �||| j�W S ty Y nw g }| j }| j}|}|| }||d krJ||krJ|�|� |r8|d }n|d8 }|| }||d krJ||ks,||krQd}n|�|� d}|�� ||fS )aW Obtain the delta chain for a revision.
``stoprev`` specifies a revision to stop at. If not specified, we
stop at the base of the chain.
Returns a 2-tuple of (chain, stopped) where ``chain`` is a list of
revs in ascending order and ``stopped`` is a bool indicating whether
``stoprev`` was hit.
r^ r TF)rl �
deltachainr� �AttributeError�append�reverse) r� r0 �stoprev�chainrl ro r` rS �stoppedrA rA rE � _deltachain� s. �
�
zrevlog._deltachainc C sZ t |�}| j}|D ]}||� q tdur | jjr tj}| j}ntj}| j}|||||d�S )z�Generate the ancestors of 'revs' in reverse revision order.
Does not generate revs lower than stoprev.
See the documentation for ancestor.lazyancestors for more details.N)rw � inclusive) �listrP � rustancestorrl �rust_ext_compat�
LazyAncestorsr) �
lazyancestors�_uncheckedparentrevs)r� r; rw r{ �checkrevrr r� �argrA rA rE � ancestors� s
zrevlog.ancestorsc C s t �|| j| j�S rg )r* �descendantrevsr; rg �r� r; rA rA rE � descendants� r6 zrevlog.descendantsc s |du r�j g}|du r��� }�fdd�|D �}�fdd�|D �}G dd� dt�}|��|��� � �t� � �|� t� }t� � fdd�|D ��}|rm|�
� }||v rUqJ|�|� �� |�D ] }|� vrj|� |� q_|sLt
|�}|�� � �fd d�|D �fS )
a� Return a tuple of the ancestors of common and the ancestors of heads
that are not ancestors of common. In revset terminology, we return the
tuple:
::common, (::heads) - (::common)
The list is sorted by revision number, meaning it is
topologically sorted.
'heads' and 'common' are both lists of node IDs. If heads is
not supplied, uses all of the revlog's heads. If common is not
supplied, uses nullid.Nc � g | ]}� � |��qS rA �r0 ��.0�nr rA rE �
<listcomp> � z,revlog.findcommonmissing.<locals>.<listcomp>c r� rA r� r� r rA rE r� r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) z)revlog.findcommonmissing.<locals>.lazysetc S s t � | _|| _d S rg )�set� addedvalues�
lazyvalues)r� r� rA rA rE r� s
z2revlog.findcommonmissing.<locals>.lazyset.__init__c S s || j v p || jv S rg �r� r� �r� �valuerA rA rE r1 ri z6revlog.findcommonmissing.<locals>.lazyset.__contains__c s s6 � | j }|D ]}|V q| jD ] }||vr|V qd S rg r� )r� �addedrr rA rA rE r5 s �
��z2revlog.findcommonmissing.<locals>.lazyset.__iter__c S � | j �|� d S rg )r� rL r� rA rA rE rL & � z-revlog.findcommonmissing.<locals>.lazyset.addc S r� rg )r� �update)r� �valuesrA rA rE r� ) r� z0revlog.findcommonmissing.<locals>.lazyset.updateN)rW rX rY r� r1 r5 rL r� rA rA rA rE �lazyset s r� c 3 s � | ] }|� vr|V qd S rg rA �r� rr )�hasrA rE � <genexpr>2 s � z+revlog.findcommonmissing.<locals>.<genexpr>c r� rA �rP )r� �missr rA rE r� > r� )r� �heads�objectr� rL r r� r� � collections�deque�popleftrg ru r| �sort)r� �commonr� r� �missing�visitrr �prA )r� r� rE �findcommonmissing s2
�� zrevlog.findcommonmissingc C s: |du rt g}tdur| jjrt�| j|�S t�| j|�S )aO Return an object that can be used to incrementally compute the
revision numbers of the ancestors of arbitrary sets that are not
ancestors of common. This is an ancestor.incrementalmissingancestors
object.
'common' is a list of revision numbers. If common is not supplied, uses
nullrev.
N)r r} rl r~ �MissingAncestorsr) �incrementalmissingancestorsrg )r� r� rA rA rE �incrementalmissingrevs@ s
z revlog.incrementalmissingrevsc C s4 |du rt g}|du r| �� }| j|d�}|�|�S )ax Return the revision numbers of the ancestors of heads that
are not ancestors of common.
More specifically, return a list of revision numbers corresponding to
nodes N such that every N satisfies the following constraints:
1. N is an ancestor of some node in 'heads'
2. N is not an ancestor of any node in 'common'
The list is sorted by revision number, meaning it is
topologically sorted.
'heads' and 'common' are both lists of revision numbers. If heads is
not supplied, uses all of the revlog's heads. If common is not
supplied, uses nullid.N�r� )r �headrevsr� �missingancestors�r� r� r� �incrA rA rE �findmissingrevsP s
zrevlog.findmissingrevsc sh |du r� j g}|du r� �� }� fdd�|D �}� fdd�|D �}� j|d�}� fdd�|�|�D �S )a. Return the ancestors of heads that are not ancestors of common.
More specifically, return a list of nodes N such that every N
satisfies the following constraints:
1. N is an ancestor of some node in 'heads'
2. N is not an ancestor of any node in 'common'
The list is sorted by revision number, meaning it is
topologically sorted.
'heads' and 'common' are both lists of node IDs. If heads is
not supplied, uses all of the revlog's heads. If common is not
supplied, uses nullid.Nc r� rA r� r� r rA rE r� | r� z&revlog.findmissing.<locals>.<listcomp>c r� rA r� r� r rA rE r� } r� r� c r� rA r� r� r rA rE r� � r� )r� r� r� r� r� rA r rE � findmissingh s zrevlog.findmissingc
s" g g g f}|dur t |�}|s|S t�fdd�|D ��}n�jg}t}|tkr=|du r=�fdd��D ��jgt ��� �fS |du rLt��d }d� i }n�t |�}|sT|S t� � t�|d�}t|�}t �fdd�|D ��}|r�|�
� }|�jkrxql�� |�}||kr�|� vr�� � |� |�
�fdd���|�D �� n ||v r�|�
|� |sn� s�|S |tkrƇ fd d�|D �}|r�t�fd
d�|D ��}n|S t}�jg}t|�} | �� }g }
�jt |d �|d d �D ]�}��|�}d} |tkr�d
} nC|| v �rd
} ||v �rt��|��} | d | v �s| d | v �r|�|� n t��|��} | d | v �s.| d | v �r5| � |� d
} | �rn� du �sB|� v �rn|
�|� � du�rV||v �rVd
||< q� du �rnd
||< ��|�D ] } |�
| d� �qdq�dd� t�|�D �}t |�}|
�s�J �|�s�J �|�s�J �|
||fS )a� Return a topological path from 'roots' to 'heads'.
Return a tuple (nodes, outroots, outheads) where 'nodes' is a
topologically sorted list of all nodes N that satisfy both of
these constraints:
1. N is a descendant of some node in 'roots'
2. N is an ancestor of some node in 'heads'
Every node is considered to be both a descendant and an ancestor
of itself, so every reachable node in 'roots' and 'heads' will be
included in 'nodes'.
'outroots' is the list of reachable nodes in 'roots', i.e., the
subset of 'roots' that is returned in 'nodes'. Likewise,
'outheads' is the subset of 'heads' that is also in 'nodes'.
'roots' and 'heads' are both lists of node IDs. If 'roots' is
unspecified, uses nullid as the only root. If 'heads' is
unspecified, uses list of all of the revlog's heads.Nc r� rA r� r� r rA rE r� � r� z'revlog.nodesbetween.<locals>.<listcomp>c r� rA r� r� r rA rE r� � r� r Fc r� rA r� r� r rA rE r� � r� c s g | ] }|� j kr|�qS rA )r� )r� r� r rA rE r� � � c s g | ]}|� v r|�qS rA rA �r� �root)r� rA rE r� � � c r� rA r� r� r rA rE r� � r� r r7 Tc S � g | ]\}}|r|�qS rA rA )r� �headr� rA rA rE r� r� )r| r� r� r r� r� r� r� �fromkeys�max�popr0 rL r� rk �copyr; rP �tuple�removeru r. r� )
r� �rootsr� �nonodes� lowestrev�
highestrev�
nodestotagr� rr r� �
orderedout� isdescendantr� rA )r� r� rE � nodesbetween� s�
�
�
�
�
�
zrevlog.nodesbetweenc C s\ |d u rz| j �� W S ty | �� Y S w td ur'| j jr't�| j |�S t�|| j�S rg )rl r� rt � _headrevs� rustdagopr~ r* r� r� rA rA rE r� " s �zrevlog.headrevsc C s | j �|�S rg )rl �computephasesmapsets)r� r� rA rA rE �
computephases, s zrevlog.computephasesc C sj t | �}|s tgS dg|d }| j}| D ]}d||< || }d ||d < ||d < qdd� t|�D �S )Nr r rc rd c S r� rA rA )r� rr �valrA rA rE r� : r� z$revlog._headrevs.<locals>.<listcomp>)r� r rl � enumerate)r� �count�isheadrl rr rS rA rA rE r� / s zrevlog._headrevsc s� |du r|du rt � �s� jgS � fdd�� �� D �S |du r"t}n� �|�}� fdd�|p/g D �}tj� j� j||d�}� fdd�|D �S )a return the list of all nodes that have no children
if start is specified, only heads that are descendants of
start will be returned
if stop is specified, it will consider all the revs from stop
as if they had no children
Nc r� rA r� r� r rA rE r� G r� z revlog.heads.<locals>.<listcomp>c s h | ]}� � |��qS rA r� r� r rA rE � <setcomp>N r� z revlog.heads.<locals>.<setcomp>)�startrev�stoprevsc r� rA r� �r� r0 r rA rE r� T r� ) r� r� r� r r0 r* �headrevssubsetr; rg )r� r8 r9 r� r; rA r rE r� < s
�z revlog.headsc C s| g }| � |�}| j|d d�D ],}dd� | �|�D �}|r/|D ]}||kr-|�| �|�� q q|tkr;|�| �|�� q|S )z!find the children of a given noder )r8 c S s g | ]}|t kr|�qS rA )r )r� �prrA rA rE r� [ r� z#revlog.children.<locals>.<listcomp>)r0 r; rg ru rP r )r� rP r r� rr �prevsr� rA rA rE �childrenV s
���zrevlog.childrenc C s0 | � |�| � |�}}| �||�}t�| j|�S )z@calculate all the heads of the common ancestors of nodes a and b)r0 �_commonancestorsheadsr. �maplistrP �r� �a�b�ancsrA rA rE �commonancestorsheadsd s zrevlog.commonancestorsheadsc G s@ z | j j|� }W |S ttfy tj| jg|�R � }Y |S w )z7calculate all the heads of the common ancestors of revs)rl r� rt �
OverflowErrorr) rg )r� r; r� rA rA rE r� j s ��z revlog._commonancestorsheadsc C s" | � |�| � |�}}| �||�S )zgreturn True if node a is an ancestor of node b
A revision is considered an ancestor of itself.)r0 �
isancestorrev�r� r� r� rA rA rE �
isancestorr s zrevlog.isancestorc C s> |t krdS ||kr dS ||krdS t| j||g|gdd��S )z�return True if revision a is an ancestor of revision b
A revision is considered an ancestor of itself.
The implementation of this is trivial but the use of
reachableroots is not.TF)� includepath)r r� �reachablerootsr� rA rA rE r� y s zrevlog.isancestorrevc
C s< z
| j �||||�W S ty t�| j||||� Y S w )zlreturn (heads(::(<roots> and <roots>::<heads>)))
If includepath is True, return (<roots>::<heads>).)rl �reachableroots2rt r* �_reachablerootspurerg )r� �minrootr� r� r� rA rA rE r� � s � ��zrevlog.reachablerootsc C sj | � |�| � |�}}z | j�||�}W n ttfy' t�| j||�}Y nw |r2tt| j |��S | j
S )z5calculate the "best" common ancestor of nodes a and b) r0 rl r� rt r� r) rg r� �maprP r� r� rA rA rE r) � s �zrevlog.ancestorc C s t |t�r
| �|�S t|�| jjkr'z
|}| �|� |W S tjy& Y nw z(t|�}d| |kr4t �|dk r>t| �| }|dk sH|t| �krJt �| �|�W S t t
fyZ Y nw t|�d| jj krz t |�}| �|� |W S t tjfy~ Y d S w d S )Ns %dr rz )
�
isinstancerN rP r� r� �nodelenr0 r+ rM r� r� r rI )r� �idrP r0 rA rA rE �_match� s>
� �
��z
revlog._matchc s� �j j�� �}d}z �j�� �}|r ��|�r |r d}n |W S |r$tj�W d S W n tjy: t �dd �s8d}Y n t
t fyD Y nw |rQt� � �j
td���� �jv r[�j� S t� �dkr�z]t� �d }t� d |d � ���fdd��jD �}� �fd d�|D �}�j j�� �r�|��j� t|�d
kr�t|�d kr�|s�|d
�j� < |d
W S t� � �j
td���|r�tj�W d S ty� Y d S w d S ) NFT� filteredrevss ambiguous identifier�( rz c s" g | ]
}|d � � �r|d �qS )r� )�
startswith)r� rS ��prefixrA rE r� � s " z(revlog._partialmatch.<locals>.<listcomp>c s( g | ]}t |��� �r��|�r|�qS rA )r r� r= r� )r� r� rA rE r� � s ���r r )r� �wdirhexr� rl � partialmatchr= r+ rL r� r rt r� �AmbiguousPrefixLookupErrorr� r
r� r� r �nullhexru r� rI )r� r� � maybewdir� ambiguous�partialrY �nlrA )r� r� r� rE �
_partialmatch� sb � �� �
�
� ��zrevlog._partialmatchc C s< | � |�}|dur |S | �|�}|r|S t�|| jtd���)z{locate a node based on:
- revision number or str(revision number)
- nodeid or subset of hex nodeid
Ns no match found)r� r� r+ rM r� r
)r� r� r� rA rA rE �lookup� s
z
revlog.lookupr c s ��fdd�}dd� � t ��}� fdd�}t�dd�sMzt�j���|�}|||�W S tjyD ��jjkrBt� ��j
t d ���Y n t yL Y nw ��jjkrmt
|t|�d
�D ]}|d|� }||�rl| S q\t
|t|�d
�D ]}|d|� }||�r�|||� S qvdS ) z7Find the shortest unambiguous prefix that matches node.c sZ z�� | �}W n tjy Y dS tjy Y dS w |d u r+t�� �jtd���dS )NFTrH )r� r+ r� rL rM r� r
)r� � matchednode)rP r� rA rE �isvalid s �z revlog.shortest.<locals>.isvalidc S s t dd� t�| �D ��S )Nc s s � | ]}|d kV qdS )� fNrA )r� r rA rA rE r� s � z5revlog.shortest.<locals>.maybewdir.<locals>.<genexpr>)�allr. � iterbytestrr� rA rA rE r� s z"revlog.shortest.<locals>.maybewdirc s8 t |t| �d �D ]}| d|� }� |�s| S q dS )z Disambiguate against wdirid.r N)�ranger� )�hexnode� minlengthrV r� )r� rA rE � disambiguate s ��z%revlog.shortest.<locals>.disambiguater� NrH r )r r r� rl �shortestr+ r� r� rJ rM r� r
rt r r� )r� rP r r� r r rV r� rA )r� rP r� rE r s: �� � � ��zrevlog.shortestc C s | � |�\}}t�|||�|kS )zpcompare text with a given file revision
returns True if text is different than what is stored.
)rk r; �hashrevisionsha1)r� rP rD �p1�p2rA rA rE �cmp? s z
revlog.cmpc
C s� | j }|| }t|d d? �}||kr||d }n|| }t|d d? �|d }| jrA||d | j j 7 }||d | j j 7 }|| } || j�|| |�fS )a� Obtain a segment of raw data corresponding to a range of revisions.
Accepts the start and end revisions and an optional already-open
file handle to be used for reading. If the file handle is read, its
seek position will not be preserved.
Requests for data may be satisfied by a cache.
Returns a 2-tuple of (offset, data) for the requested range of
revisions. Offset is the integer offset from the beginning of the
revlog and data is a str or buffer of the raw byte data.
Callers will need to call ``self.start(rev)`` and ``self.length(rev)``
to determine where each revision's data begins and ends.
r r� r )rl rN r� �
entry_sizer� �
read_chunk)
r� r� �endrev�dfrl �istartr8 rh �iendrV rA rA rE �_getsegmentforrevsG s zrevlog._getsegmentforrevsc C sh | j | d }| j|||d�d }|tkr|S |tkr | �|�S |tkr)| �|�S d}||; }t�|��)a< Obtain a single decompressed chunk for a revision.
Accepts an integer revision and an optional already-open file handle
to be used for reading. If used, the seek position of the file will not
be preserved.
Returns a str holding uncompressed data for the requested revision.
�
�r r � unknown compression mode %d) rl r r r r r r r+ r� )r� r0 r �compression_moderj r� rA rA rE �_chunki s
z
revlog._chunkc sx |sg S �j }�j}�j}�jj}tj}g } | j}
�js |f} nt j
�||d�} | D ]�} | d }
| ddd� D ]
}||�dkrA nq7z �j |
|� d�\}}W n t yc � �fdd�| D � Y S w �j
}�j}| D ]L}||�}|r|||d | 7 }||�}�j| d }|||| |�}|tkr�|
|� ql|tkr�|
||�� ql|tkr�|
||�� qld
}||; }t�|��q*| S ) a� Obtain decompressed chunks for the specified revisions.
Accepts an iterable of numeric revisions that are assumed to be in
ascending order. Also accepts an optional already-open file handle
to be used for reading. If used, the seek position of the file will
not be preserved.
This function is similar to calling ``self._chunk()`` multiple times,
but is faster.
Returns a list with decompressed data for each requested revision.
)�
targetsizer Nr} r c s g | ] }�j |� d ��qS )r )r r� �r r� rA rE r� � r� z"revlog._chunks.<locals>.<listcomp>r r r )r8 rV r� rl r r1 r� ru r� � deltautil�
slicechunkr r� r r r r r r+ r� )r� r; r r r8 rV rk �iosizer� rY �ladd� slicedchunks� revschunk�firstrev�lastrev�offsetrj �decomp�
def_decompr0 �
chunkstart� chunklength� comp_moder r� rA r rE �_chunks sZ
� � �
�zrevlog._chunksc C s, | j | d }||kr
tS | jr|S |d S )z(return deltaparent of the given revisionr^ r )rl r r� )r� r0 r_ rA rA rE � deltaparent� s zrevlog.deltaparentc C s� | j s
| �|�tkS t�| jd�r| jj| _| �|�S |tkr!dS | j| }|d }||kr0dS |tkr6dS |d }|d }||ksF||krHdS | �|�S )z tells whether rev is a snapshots
issnapshotTr^ rc rd F)r� r( r r1 r� rl �
issnapshot)r� r0 rf r_ r r rA rA rE r) � s$
zrevlog.issnapshotc C s* | � |�s
t�d��t| �|�d �d S )z/number of snapshot in the chain before this ones revision %d not a snapshotr r )r) r+ �ProgrammingErrorr� rz r/ rA rA rE �
snapshotdepth� s
zrevlog.snapshotdepthc C s< |t kr| �|�|krt| �|��S t�| �|�| �|��S )z�return or calculate a delta between two revisions
The delta calculated is in binary form and is intended to be written to
revlog data directly. So this function needs raw revision data.
)r r( �bytesr r, �textdiffrX )r� �rev1�rev2rA rA rE �revdiff� s zrevlog.revdiffc C s | � ||�S )z�return an uncompressed revision of a given node or revision
number.
_df - an existing file handle to read from. (internal-only)
��
_revisiondata�r� � nodeorrev�_dfrA rA rE rM � s zrevlog.revisionc C s$ t |t�r|}n| �|�}| �|�S )z�a map of extra data related to the changeset but not part of the hash
This function currently return a dictionary. However, more advanced
mapping object will likely be used in the future for a more
efficient/lazy code.
)r� rN r0 � _sidedata)r� r4 r5 r0 rA rA rE r: � s
zrevlog.sidedatac C s� t |t�r
|}| �|�}n|}d }|| jkrdS | j|||d�\}}}|r)|r)|S |d u r2| �|�}| �|�}|r?|tkr?|S |rKt� | ||�} |}
n t�
| ||�} | \}
} | r`| j |
||d� |sh|||f| _ |
S )Nr| )r5 r� )
r� rN rP r� �_rawtextr0 r^ r! r5 �processflagsraw�processflagsread� checkhashr� ) r� r4 r5 �rawr0 rP �rawtext� validatedr^ � validatehashrD rr rA rA rE r2
s2
zrevlog._revisiondatac C s� d}d}| j r| j d |kr|| j d dfS | j d }|du r$| �|�}| j||d�\}}|r4| j d }d| _ d}| j| d } d| krHd| }| j|||d�}
|du r`t|
d �}|
dd� }
t�||
�} ~|| d fS )
zjreturn the possibly unvalidated rawtext for a revision
returns (rev, rawtext, validated)
Nr rz Tr )rw r� )r r F)r� r0 rz rl r' r, r, �patches) r� rP r0 r5 � cachedrev�basetextrx ry r rZ �binsr< rA rA rE r7 6 s.
zrevlog._rawtextc C s� | j | }|d }|d }| jr|| j jd| 7 }|dkr i S | jj|| k r@| j}| jj}|}|}t||||f } t�| ��| j �
||�}
| j | d } | t krU|
} n | t kr_| �
|
�} n| tkri| �|
�} n d}
|
| ; }
t�|
��t�| �}|S )z0Return the sidedata for a given revision number.rO rP r r � r )rl r� r r� � sidedata_endr� �FILE_TOO_SHORT_MSGr+ r� r� r r r r r r � sidedatautil�deserialize_sidedata)r� r0 � index_entry�sidedata_offset�
sidedata_size�filenamerh r! rV �m� comp_segment�comp�segmentr� r: rA rA rE r6 a s:
�
zrevlog._sidedatac C s | j ||dd�S )z�return an uncompressed raw data of a given node or revision number.
_df - an existing file handle to read from. (internal-only)
T)r; r1 r3 rA rA rE rX � s zrevlog.rawdatac C s t �|||�S )zyCompute a node hash.
Available as a function so that subclasses can replace the hash
as needed.
)r; r )r� rD r r rA rA rE �hash� s z revlog.hashc C s� zD|du r|du r| � |�\}}|| �|||�krB| jr&| jd |kr&d| _|}|du r3t�t|��}t�td�| j t
� |�f ��W dS tjy] | j r\t
�|�r\t�| j ||��� w )z�Check node hash integrity.
Available as a function so that subclasses can extend hash mismatch
behaviors as needed.
Nr s integrity check failed on %s:%s)rk rP r� r0 r r r+ r� r
r� r. �bytestrr� r; �iscensoredtext�CensoredNodeError)r� rD rP r r r0 � revornoderA rA rE r: � s( ����zrevlog.checkhashc C s� t | �d }| �|�| �|� }| jr|tk rdS |�| j�}|du r-t�t d�| j ��d}|�
| j d� d}| j durSd}| j d }|�
� |�� d| _ d| j_| �d�}|�d� z�| �� �1} | D ]"}
|�| j|
|
| d�d � |du r�|| �|
�|
| jj kr�|
}qe|�
� W d � n1 s�w Y |du r�d}| �� �Q}| jt M _d| _| D ]&} | j�| �} | dkr�| j du r�| j| j B }
| j� |
�}
|
| } |�| � q�| j dur�|� � | j _ |�!| j | �|�� W d � n1 s�w Y |�!| j|| jj � t"�#|| � t$�$| j%| j | j&�| _|�r-| �'� }||df| _ || j_d}W |du�r9|�� dS dS |du�rE|�� w w ) a Check if the revlog is too big for inline and convert if so.
This should be called after revisions are added to the revlog. If the
revlog has grown too large to be an inline revlog, it will convert it
to use multiple index and data files.
r Ns %s not found in the transactionr FTr r )(r� r8 rV r� �
_maxinline�
findoffsetr� r+ r� r
rL r� r� �flush�closer� �writing_handler( �truncater �writer rl r �_revlog__index_new_fpr� r � entry_binaryr� r� � pack_header�tellr� �replacer� rA r7 r� r� �_revlog__index_write_fp)r� �trr, �
total_size�troffset�trindex�existing_handlesr� �new_dfh�read_ifhrr rj rS r� �ifhrA rA rE �_enforceinlinesize� s� �
��
�
� � �
�
�zrevlog._enforceinlinesizec C rI )z0called when trying to add a node already stored.NrA )r� rC rP rA rA rE �_nodeduplicatecallback s z revlog._nodeduplicatecallbackc c sr � | j �� �) | j�� � dV W d � n1 sw Y W d � dS W d � dS 1 s2w Y dS )zCContext manager that keeps data and sidedata files open for readingN)r� �readingr� r rA rA rE rl s � ��"�zrevlog.readingc
c s� � | j rd}|| j; }t�|��| jd urd V d S d } }}�z
t| �}d}|r1| �|d �}d }| jsyz | �d�}| j d u rI|�
dt j � n |�
| j j
t j� W n tyq } z|jtjkrb� | �d�}W Y d }~nd }~ww |�| j|� | jd ur�|d us�J �z| j| jdd�}|�
| j jt j� W n! ty� } z|jtjkr�� | j| jdd�}W Y d }~nd }~ww |�| j| j j� || jj } | �� }| jr�|�| j|| � n|�| j| � |||f| _| jr�|n|| j_ || j _ d V | j d u�r| � |� W d | _d | j_ d | j _ |d u�r|� � |d u�r |� � |d u�r*|� � d S d S d | _d | j_ d | j _ |d u�r@|� � |d u�rI|� � |d u�rS|� � w w )Ns) try to write in a `trypending` revlog: %sr r r r r ) r� r� r+ r* r� r� rh r� r( r� r r r! �data_endr" r� r� r� rL r� r� r� rD rl r ra r� r� rY r� �
_write_docketrX )
r� rC r� ri �dfh�sdfhrr �dsizer� �isizerA rA rE �_writing s� �
� ��
��
�
�
��
�zrevlog._writingc C s | j �|� dS )z�write the current docket on disk
Exist as a method to help changelog to implement transaction logic
We could also imagine using the same transaction logic for all revlog
since docket are cheap.N)r� r[ rB rA rA rE rn c s zrevlog._write_docketc C s� |t krt�td�| j ��|
du ri }
n |
r!| js!t�td���|r,|p+| �|||�}t� | ||�\} } | |kr;d}t
| �t krOt�td�| jt
| �f ��|pW| �| ||�}| j �
|�}
|
durd|
S | ro| j| |||d� | j| |||||||| |
d�
S )a� add a revision to the log
text - the revision data to add
transaction - the transaction object used for rollback
link - the linkrev data to add
p1, p2 - the parent nodeids of the revision
cachedelta - an optional precomputed delta
node - nodeid of revision; typically node is not specified, and it is
computed by default as hash(text, p1, p2), however subclasses might
use different hashing method (and override checkhash() in such case)
flags - the known flags to set on the revision
deltacomputer - an optional deltacomputer instance shared between
multiple calls
s! attempted to add linkrev -1 to %sNs9 trying to add sidedata to a revlog who don't support thems; %s: size of %d bytes exceeds maximum revlog storage of 2GiB)r r )�
cachedelta�
deltacomputerr: )r r+ r� r
r� r� r* rP r5 �processflagswriter� �
_maxentrysizerl �get_revr: �addrawrevision)r� rD rC �linkr r rt rP r^ ru r: r< r> r0 rA rA rE � addrevisionl sR �
� � �� �zrevlog.addrevisionc
C sL | � |�� | j||||||||| |
d�
W d � S 1 s w Y dS )z�add a raw revision with known flags, node and parents
useful when reusing a revision not stored in this revlog (ex: received
over wire, or read from an external bundle).
�ru r: N)rs � _addrevision) r� r< rC rz r r rP r^ rt ru r: rA rA rE ry � s �$�zrevlog.addrawrevisionc C sD |sd|fS | j �|�}|rd|fS |dd� dkr d|fS d|fS )z6Generate a possibly-compressed representation of data.r| r r � � u)r �compress)r� rj �
compressedrA rA rE r� � s zrevlog.compressc
C s� |s|S |dd� }|dkr-zt |�W S tjy, } z t�td�t�|� ��d}~ww |dkr3|S |dkr=t�|d�S | � |�}|�
|�S )z�Decompress a revlog chunk.
The chunk is expected to begin with a header identifying the
format type so it can be routed to an appropriate decompressor.
r r � xs revlog decompress error: %sNr~ r ) �_zlibdecompress�zlibr+ r� r
r< � forcebytestrr1 r� r r )r� rj r rS r rA rA rE r � s(
����
zrevlog.decompressc ( C s� || j krt�td�| j ��|| jjks|| jjv r%t�td�| j ��| jdu r1d} t� | ��| j
r:| jd }
n| jd }
|g}t | �}|d }| � |�}| j
r~| j\}}}| j
rj| �
|| j||| jj � n| �
|| j|| jj � | �
|| j|� | �|�| �|�}}|du r�t�t�| |d �|d �}nt |�}|
du r�t�| �}
t�|||||||�}|
�||
�}t }| j dur�| j j }t� ||�} | \}}t } | �r| j �rt!} t"�#| �} | j j$} | �%| �\} }!| dk�r|!dd� dk�rt |!�t | �k �r| �rJ �|!dd� | j j k�rt&} |!} n t } |!} nd } d} t'}"| j(t)k�rw||ft*t*fk�r3d}"nD|t*k�rE|t*k�rEd| �+|� }"n2|t*k�rW|t*k�rWd| �+|� }"n t,||f�\}#}$d| �+|$� }"|"t-d
d � | �.|$g|#g�D ��7 }"tj/|||j0|||j1||||| t | �| |"d �}%| j�2|%� | j�3|�}&|dk�r�| j du �r�| j4| j(B }'| j�5|'�}'|'|& }&| �6||&|j7||| | � |d }| �r�|du �r�|
�8||
�}t9|�t:k�r�|||f| _;|j<| j=|< |S )
a� internal function to add revisions to the log
see addrevision for argument descriptions.
note: "addrevision" takes non-raw text, "_addrevision" takes raw text.
if "deltacomputer" is not provided or None, a defaultdeltacomputer will
be used.
invariants:
- rawtext is optional (can be None); if not set, cachedelta must be set.
if both are set, they must correspond to each other.
s %s: attempt to add null revisions %s: attempt to add wdir revisionN�1 adding revision outside `revlog._writing` contextr r r r~ r| c s s � | ]}d V qdS )r NrA )r� r
rA rA rE r� � s � z&revlog._addrevision.<locals>.<genexpr>)r^ � data_offset�data_compressed_length�data_uncompressed_length�data_compression_mode�data_delta_base�link_rev� parent_rev_1� parent_rev_2�node_idrI �sidedata_compressed_length�sidedata_compression_moder\ )>r� r+ r� r
r� r� rJ rK r� r* r� r� �_get_data_offsetr� r� rl r r� r0 r, � patchedsizer> r� r ru r/ � revisioninfo�
finddeltainfor r� r �delta_compressionr� r rF �serialize_sidedatarD r� r r r� r
r r] �sorted�sumr� rf �deltalenr_ ru r] r� r^ � _writeentryrj � buildtext�typer, r� ra r� )(r� rP r< rC rz r r r^ rt � alwayscacheru r: r� �fh�btext�curr�prevr! ri ro rp �p1r�p2r�textlen�revinfo� deltainfor � default_comprr r� �serialized_sidedatarI �h�
comp_sidedatar\ �pmin�pmaxrS rf r� rA rA rE r} s�
� �
���
�
�� "� �
zrevlog._addrevisionc C s | j du r
| �|�S | j jS )a Returns the current offset in the (in-transaction) data file.
Versions < 2 of the revlog can get this 0(1), revlog v2 needs a docket
file to store that information: since sidedata can be rewritten to the
end of the data file within a transaction, you can have cases where, for
example, rev `n` does not have sidedata while rev `n - 1` does, leading
to `n - 1`'s sidedata being written after `n`'s data.
TODO cache this in a docket file before getting out of experimental.N)r� rh rm )r� r� rA rA rE r� � s
zrevlog._get_data_offsetc C s� | j d u r d}t�|��| j \} }
} | jd u r | �dtj� n | �| jjtj� |
r@| jd u r7|
�dtj� n |
�| jj tj� | rK| �| jj
tj� t | �d } | j s�|�
| j|� | jre|�
| j|� |�
| j| t |� � |d r{|
�|d � |
�|d � |r�| �|� | �|� n+|| | jj 7 }|�
| j|� | �|� | �|d � | �|d � |r�J �| �|� | jd ur�| j d }
| j d }| j d }|
d us�J �|d us�J �|d us�J �|
�� | j_|�� | j_ |�� | j_
t�|| � d S )Nr� r r rz )r� r+ r* r� r r r! r� r" rm rD r� r� rL r� r� r� r[ rl r rj r_ r� rA )r� rC rf rj rz r! r: rI r� ri ro rp r� �wh1�wh2�wh3rA rA rE r� � sV
zrevlog._writeentryc C s� | j rt�d��d| _ d}z�| �|��� t�| �}|D ]�} | \}
} } }
}}}}||
�}|p.t}| j�|
�}|durI| � ||� |rF|| |� d}q| | fD ]}| j�
|�s_t� || j t
d���qM| j�
|�spt� || jt
d���| �|�}|tkr�| �|�r�t�d�}| �|�}t|�| }|d|� t�||�kr�t�| j| �|���|s�| �||�r�|tO }| j |
d||| | |||f|||d� }|r�|| |� d}qW d � n1 s�w Y W d| _ | S W d| _ | S d| _ w ) a\
add a delta group
given a set of deltas, add them to the revision log. the
first delta is against its parent, which should be in our
log, the rest are against the previous delta.
If ``addrevisioncb`` is defined, it will be called with arguments of
this revlog and the node that was added.
s cannot nest addgroup() callsTNFs unknown parents unknown delta bases >lll)r� ru r: ) r� r+ r* rs r ru r! rl rx rk �has_noderM r r
r� r0 r �
iscensored�struct�calcsizerZ r� r, �replacediffheader�CensoredBaseErrorrP �_peek_iscensoredr& r} )r� r3 �
linkmapperrC r� �
addrevisioncb�duplicaterevisioncb�emptyru rj rP r r rb � deltabaser` r^ r: rz r0 r� r> �hlen�oldlen�newlenrA rA rE �addgroup&
s�
�
�� �
� � �
� �P�P�zrevlog.addgroupc C s | j sdS | �|�t@ S )z%Check if a file revision is censored.F)r� r^ r& r/ rA rA rE r� �
s zrevlog.iscensoredc C s | j sdS t�||| j�S )z6Quickly check if a delta produces a censored revision.F)r� r; �deltaiscensoredrZ )r� r> r` rA rA rE r� �
s zrevlog._peek_iscensoredc C s" t �|t| �d | �� | j| j�S )z�find the minimum rev that must be stripped to strip the linkrev
Returns a tuple containing the minimum rev and a set of all revs that
have linkrevs that will be broken by this strip.
r )r; �resolvestripinfor� r� rb rg )r� �minlinkrA rA rE �
getstrippoint�
s
�zrevlog.getstrippointc C s� t | �dkrdS | �|�\}}|t | �krdS | �|�}| js-|�| j|� || jj }n||| jj }| jrD| � |�}|�| j|� |�| j
|� | j durd|| j _ || j _
|| j _| j j|dd� d| _t�d�| _| j�� | j�� | j|d�= dS )a7 truncate the revlog on the first revision with a linkrev >= minlink
This function is called when we're stripping revision minlink and
its descendants from the repository.
We have to remove all revisions with linkrev >= minlink, because
the equivalent changelog revisions will be renumbered after the
strip.
So we truncate the revlog on the first of these revisions, and
trust that the caller has saved the revisions that shouldn't be
removed and that it'll re-add them after this truncation.
r NT)� strippingr� r} )r� r� r8 r� rL r� rl r r� rT r� r� r� rm rD r[ r� r1 r� r� r� rF r� )r� r� rC r0 r
rm rh rD rA rA rE �strip�
s0
z revlog.stripc
C s� d}t | �rtd| �t | �d ��}z%| �� �}|�dtj� |�� }W d � n1 s-w Y || }W n tyR } z|j t j
krF� d}W Y d}~nd}~ww zP| � | j �}|�dtj� |�� }|�
� | jj}td|| �}||| }| jr�d} | D ] }
| td| �|
��7 } q�d}|t | �| | }W ||fS W ||fS ty� } z|j t j
kr�� d}W Y d}~||fS d}~ww )z�Check size of index and data files
return a (dd, di) tuple.
- dd: extra bytes for the "data" file
- di: extra bytes for the "index" file
A healthy revlog will return (0, 0).
r r N)r� r� rh r( r �ior! r_ r� r� r� r� r� rX rl r r� rV ) r� �expectedr# �actual�ddr� �srj �di� databytesrr rA rA rE � checksize�
sN
� �� � � ��zrevlog.checksizec C s� | j g}| jd u r| js|�| j� |S |�| j� |�| jjdd�� | jjr.|�| j� |�| jj dd�� | jj
rB|�| j � |�| jj dd�� |S )NF)�
include_empty)
r� r� r� ru r� �extendr� �old_index_filepathsrm �old_data_filepathsrD r� �old_sidedata_filepaths)r� �resrA rA rE �files
s
� z revlog.filesc C sl |dvr t �d| ��|d u r| jsd}| js |tjkr tj}tj| ||t | j
| j | j | j
| j||||d�
S )N)s nodes� storages linearNs" unhandled value for nodesorder: %sr� ) �
deltaparentfn�
candeltafn� rawsizefn� revdifffn�flagsfn� deltamode� revisiondata�assumehaveparentrevisions�sidedata_helpers)r+ r* r� r� r2 �CG_DELTAMODE_PREV�CG_DELTAMODE_FULLr; �
emitrevisionsrT r( r? rZ r0 r^ )r� �nodes�
nodesorderr� r� r� r� rA rA rE r� s2 ��
�zrevlog.emitrevisions� always� samerevs� never� fulladd> r� r� r� r� c
C s || j vr
ttd�| ��t|�rttd���t| dd�r#ttd���t|dd�r/ttd���|j}|j}|j} z>|| jkrEd|_d|_n|| j krQd|_d|_n || j
kr\d|_d|_|p_| |_| � ||||||� W ||_||_| |_dS ||_||_| |_w ) a] Copy this revlog to another, possibly with format changes.
The destination revlog will contain the same revisions and nodes.
However, it may not be bit-for-bit identical due to e.g. delta encoding
differences.
The ``deltareuse`` argument control how deltas from the existing revlog
are preserved in the destination revlog. The argument can have the
following values:
DELTAREUSEALWAYS
Deltas will always be reused (if possible), even if the destination
revlog would not select the same revisions for the delta. This is the
fastest mode of operation.
DELTAREUSESAMEREVS
Deltas will be reused if the destination revlog would pick the same
revisions for the delta. This mode strikes a balance between speed
and optimization.
DELTAREUSENEVER
Deltas will never be reused. This is the slowest mode of execution.
This mode can be used to recompute deltas (e.g. if the diff/delta
algorithm changes).
DELTAREUSEFULLADD
Revision will be re-added as if their were new content. This is
slower than DELTAREUSEALWAYS but allow more mechanism to kicks in.
eg: large file detection and handling.
Delta computation can be slow, so the choice of delta reuse policy can
significantly affect run time.
The default policy (``DELTAREUSESAMEREVS``) strikes a balance between
two extremes. Deltas will be reused if they are appropriate. But if the
delta could choose a better revision, it will do so. This means if you
are converting a non-generaldelta revlog to a generaldelta revlog,
deltas will be recomputed if the delta's parent isn't a parent of the
revision.
In addition to the delta policy, the ``forcedeltabothparents``
argument controls whether to force compute deltas against both parents
for merges. By default, the current default is used.
See `revlogutil.sidedata.get_sidedata_helpers` for the doc on
`sidedata_helpers`.
s value for deltareuse invalid: %ss destination revlog is not emptyr� Ns$ source revlog has filtered revisionss) destination revlog has filtered revisionsTF) �
DELTAREUSEALLr� r
r� r r� r� r� �DELTAREUSEALWAYS�DELTAREUSESAMEREVS�DELTAREUSENEVER�_clone)
r� rb �
destrevlogr� �
deltareuse�forcedeltabothparentsr� � oldlazydelta�oldlazydeltabase�oldamdrA rA rE �cloneL sL
5
�
�
�z revlog.clonec C s� t �|�}| j}| D ]�} || }
|
d d@ } |
d } ||
d d }
||
d d }|
d }d}d}|| jkrj| �| �}| �| �}|durZt�| ||| �\}}| |d |d @ B } |j||| |
|||| ||d �
ni|j r| �
| �}|t kr|t | �
| ��f}d}|s�| �| �}| �| �}|du r�| �| �}|dur�t�| ||| �\}}| |d |d @ B } |�|�� |j|||| |
|| |||d
�
W d � n1 s�w Y |r�|| | |� q
dS ) zBperform the core duty of `revlog.clone` after parameter processingr r� r� rc r� rd Nr )rt rP r^ ru r: r| )r ru rl �DELTAREUSEFULLADDr2 r: rF �run_sidedata_helpersr{ r� r( r r, r rs r} )r� rb r� r� r� r� r� ru rl r0 rf r^ rb r r rP rt r< rD r: � new_flags�dprA rA rE r� � s�
��
� � � ��z
revlog._cloner| c C sP | j tkrt�td�| j ��| j tkr t�| |||� d S t�| |||� d S )Ns% cannot censor with version %d revlogs) r� r r+ r� r
r r9 � v1_censor� v2_censor)r� rb �
censornode� tombstonerA rA rE �censorrevision s
��
zrevlog.censorrevisionc c s� � | � � \}}|rttd�| d�V |r ttd�| d�V | j}||d kr8ttd�| j||d f d�V t� |d< t� |d< | D ]�}| �|�}z5|�d d
�}|r[|| �|�M }t | |||� | �
|�}t | � |��} || krttd �| |f |d �V W qD t
jy� |d
r�ttd�|d �V |d �|� Y qD ty� }
z ttd�t|�t�|
�f |d �V |d �|� W Y d}
~
qDd}
~
ww dS )z�Verifies the integrity of the revlog.
Yields ``revlogproblem`` instances describing problems that are
found.
s data length off by %d bytes)r+ s index contains %d extra bytess expectedversions0 warning: '%s' uses revlog format %d; expected %d)re rK s safe_renameds skipflagsr s unpacked size is %d, %d expected)r+ rP s erroroncensoreds censored file datas unpacking %s: %sN)r� rd r
r� r� r� rP r� r^ rQ rZ r� rX r+ rS rL � Exceptionr r< r� ) r� rO r� r� �versionr0 rP rN �l1�l2rS rA rA rE �verifyintegrity s` � ��
2
���������zrevlog.verifyintegrityc s� i }|r� j � jfg|d< � js|d �� j � jf� |r!g |d< |r)t� �|d< |r7tt� jt � ���|d< |rHt� fdd�� �
� D ��|d< |S )Ns exclusivefiless sharedfiless revisionscounts trackedsizec 3 s � | ]
}� j �|�jV qd S rg )r� �statr� )r� �pathr rA rE r� � s �
�z%revlog.storageinfo.<locals>.<genexpr>s
storedsize) r� r� r� ru r� r� r� r� rZ r3 r� )r� �exclusivefiles� sharedfiles�revisionscount� trackedsize�
storedsizer rA r rE � storageinfox s �zrevlog.storageinfoc C sF | j sd S | jr
J �|d s|d sd S g }| �|��� | j\}}}|�| jjtj� |� � } t
||d �D ]�}
| j |
} t j
| |i |
d�\} }
t �| �}t}|r�| j r�t}| �|�\}}|dkr�|d dkr�t|�t|�k r�|rsJ �|d | jjkr�t}|}nt}|}| d dks�| d dkr�d }t�|��| d |
d |
d @ B }| t|�||f}|�| tj� |�|� |�|� | t|�7 } |� � | j_q6|�|| j j � t|�D ]8\}}|| }
| j j|
g|�R � | j � |
�}|
dk�r
| jd u �r
| j | j B }| j � |�}|| }|�|� q�W d � d S 1 �s w Y d S )
Nr rz )�storer� r: r0 r r r~ rO rP s0 rewriting existing sidedata is not supported yet) r� r� rs r� r r� rD r r" r_ r rl rF r� r� r r r� r� r r r+ �Abortr[ ru r r� �replace_sidedata_infor] r� r� r^ )r� rC �helpersr� r
� new_entriesri ro rp �current_offsetr0 rf � new_sidedatar^ r� r� r� r� r� �new_offset_flags� entry_updaterj rS �packedr� rA rA rE �rewrite_sidedata� s|
��
�
�
�$�zrevlog.rewrite_sidedata)NFFFNFNFrg )r )r N)r F)NN)F)r r@ )NNN)FNN)r| )FFFFF)~rW rX rY �__doc__r+ r� �_flagserrorclassr� r� r� r� r1 �
propertycacher� r� r r r r ra r\ r( �
contextlib�contextmanagerr) r, r. r1 r2 r5 r; r= r? rD rG r0 r8 rT r^ rV rW rZ r� r] ra rb rg r� rP rh rk rm rl rz r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r) r� r� r� r r
r r r' r( r) r+ r0 rM r: r2 r7 r6 rX rP r: rj rk rl rs rn r! r{ ry r� r r} r� r� r� r� r� r� r� r� r� r2 �CG_DELTAMODE_STDr� r� r� r� r� r� r� r� r� r r
r rA rA rA rE r> � sB -
�X
R
)
@
!
":
3
"
D
,+
&
^
E
�W
� <
� >F
�m2,
�'
�c
U k
� )pr �
__future__r r
r� r r� r� r r� r� rP r r r r r r �i18nr
r. r �revlogutils.constantsr r
r r r r r r r r r r r r r r r r r r r �revlogutils.flagutilr! r" r# r$ r% r& r' �
thirdpartyr( � r) r* r+ r, r- r/ r0 r1 �
interfacesr2 �
interfaceutilr3 r r4 r� r5 r6 r� r7 r8 r9 r: rF �utilsr; r< � importmodr= �
importrustr} r� rw r r� rU rF rH rJ r� rQ r� �HAS_FAST_PERSISTENT_NODEMAP� implementer�irevisiondeltar� r� rT �iverifyproblemrd rn rr rt rv ry rw rE r> rA rA rA rE �<module> s� \$ , (
��
�