| Server IP : 104.21.74.243 / Your IP : 216.73.216.47 Web Server : Apache System : Linux infong-es77 4.4.400-icpu-108 #2 SMP Wed Feb 11 10:12:42 UTC 2026 x86_64 User : u67207989 ( 1351568) PHP Version : 8.4.24 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/breezy/bzr/__pycache__/ |
Upload File : |
a
�*�^�] � @ s� d dl mZ d dlZd dlZddlmZ ee� d� ddlmZmZm Z ddl
m Z ddl m
Z
dd lmZ dd
lmZmZ dd lmZmZ dd lmZmZ dd
lmZmZm Z ddl m Z m Z m Z G dd� de �Z!G dd� de"�Z#G dd� de#�Z$G dd� de$�Z%G dd� de#�Z&G dd� de"�Z'G dd � d e"�Z(G d d � d e"�Z)G d d � d e�Z*G d!d"� d"e�Z+G d#d$� d$ej,�Z-G d%d&� d&e"�Z.dS )'� )�absolute_importN� )� lazy_importz�
import time
from breezy import (
cleanup,
config,
debug,
graph,
osutils,
transactions,
ui,
)
from breezy.bzr import (
pack,
)
from breezy.bzr.index import (
CombinedGraphIndex,
)
)�errors�lockable_files�lockdir)� btree_index)� only_raises)�LogicalLockResult)�
_LazyListJoin�RepositoryWriteLockResult)�MetaDirRepository�RepositoryFormatMetaDir)�reraise� viewitems)� MetaDirVersionedFileRepository�$MetaDirVersionedFileRepositoryFormat�VersionedFileCommitBuilder)�mutter�note�warningc @ s" e Zd ZdZddd�Zdd� ZdS ) �PackCommitBuilderz�Subclass of VersionedFileCommitBuilder to add texts with pack semantics.
Specifically this uses one knit object rather than one knit object per
added text, reducing memory and object pressure.
NFc
C s4 t j| ||||||||| d�
t�|jjj�| _d S )N)� timestamp�timezone� committer�revprops� revision_id�lossy)r �__init__�graphZGraph�_pack_collection�
text_index�combined_index� _file_graph)
�self�
repository�parents�configr r r r r r � r( �6/usr/lib/python3/dist-packages/breezy/bzr/pack_repo.pyr V s ��zPackCommitBuilder.__init__c s( � fdd�|D �}dd� | j �|�D �S )Nc s g | ] }� |f�qS r( r( )�.0r ��file_idr( r) �
<listcomp>` � z,PackCommitBuilder._heads.<locals>.<listcomp>c S s h | ] }|d �qS �� r( �r* �keyr( r( r) � <setcomp>a r. z+PackCommitBuilder._heads.<locals>.<setcomp>)r# Zheads)r$ r, � revision_ids�keysr( r+ r) �_heads_ s zPackCommitBuilder._heads)NNNNNF)�__name__�
__module__� __qualname__�__doc__r r6 r( r( r( r) r O s �
r c @ s� e Zd ZdZdddddd�Zd%d d
�Zd d � Zd
d� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd � Zd d � Zd d � Zd!d"� Zd#d$� ZdS )&�Packz�An in memory proxy for a pack and its indices.
This is a base class that is not directly used, instead the classes
ExistingPack and NewPack are used.
)�.cix� )�.rixr )�.iixr0 )�.tixr )�.six� )�chk�revision� inventory�text� signatureNc C s" || _ || _|| _|| _|| _dS )a= Create a pack instance.
:param revision_index: A GraphIndex for determining what revisions are
present in the Pack and accessing the locations of their texts.
:param inventory_index: A GraphIndex for determining what inventories are
present in the Pack and accessing the locations of their
texts/deltas.
:param text_index: A GraphIndex for determining what file texts
are present in the pack and accessing the locations of their
texts/deltas (via (fileid, revisionid) tuples).
:param signature_index: A GraphIndex for determining what signatures are
present in the Pack and accessing the locations of their texts.
:param chk_index: A GraphIndex for accessing content by CHK, if the
pack has one.
N)�revision_index�inventory_indexr! �signature_index� chk_index)r$ rH rI r! rJ rK r( r( r) r u s
z
Pack.__init__c C s | j | �� fS )�6Return a tuple (transport, name) for the pack content.)�pack_transport� file_name�r$ r( r( r) � access_tuple� s zPack.access_tuplec C s� i }d| � | j�| jjjfd| � | j�| jjjffD ]8\}}}|�dd� |�|�D ��}|r4tt|��||< q4|r�ddl m
} t � d| ||�f ��dS ) aB Make sure our external references are present.
Packs are allowed to have deltas whose base is not in the pack, but it
must be present somewhere in this collection. It is not allowed to
have deltas based on a fallback repository.
(See <https://bugs.launchpad.net/bzr/+bug/288751>)
�texts� inventoriesc s s | ]\}}}}|V qd S �Nr( )r* �idx�k�v�rr( r( r) � <genexpr>� s z)Pack._check_references.<locals>.<genexpr>r )�pformatzRNewly created pack file %r has delta references to items not in its repository:
%sN)
�_get_external_refsr! r r" rI �
differenceZ iter_entries�sorted�listZpprintrY r �
BzrCheckError)r$ Z
missing_items�
index_nameZ
external_refs�index�missingrY r( r( r) �_check_references� s,
�
��
�
��zPack._check_referencesc C s
| j d S )z'Get the file name for the pack on disk.�.pack��namerO r( r( r) rN � s zPack.file_namec C s
| j �� S rS )rH � key_countrO r( r( r) �get_revision_count� s zPack.get_revision_countc C s |t j| d S )z8Get the disk name of an index type for pack name 'name'.r �r; �index_definitions)r$ �
index_typere r( r( r) r_ � s zPack.index_namec C s t j| d S )z>Get the position in a index_size array for a given index type.r0 rh )r$ rj r( r( r) � index_offset� s zPack.index_offsetc C s | � d|�S )z!The inv index is the name + .iix.rE �r_ �r$ re r( r( r) �inventory_index_name� s zPack.inventory_index_namec C s | � d|�S )z&The revision index is the name + .rix.rD rl rm r( r( r) �revision_index_name� s zPack.revision_index_namec C s | � d|�S )z'The signature index is the name + .six.rG rl rm r( r( r) �signature_index_name� s zPack.signature_index_namec C s | � d|�S )z"The text index is the name + .tix.rF rl rm r( r( r) �text_index_name� s zPack.text_index_namec C s^ d}|dkrd}| j | j| �|| j�| j| �|� |d�}|dkrJtj|_t | |d |� d S )NFrC T��unlimited_cache�_index)
� index_class�index_transportr_ re � index_sizesrk r �_gcchk_factory�
_leaf_factory�setattr)r$ rj rs r` r( r( r) � _replace_index_with_readonly� s ��z!Pack._replace_index_with_readonlyc C s" t |t�st|��t| �t|�k S rS )�
isinstancer; � TypeError�id�r$ �otherr( r( r) �__lt__� s
z Pack.__lt__c C s" t t| �| j| j| j| j| jf�S rS )�hash�typerH rI r! rJ rK rO r( r( r) �__hash__� s �z
Pack.__hash__)N)r7 r8 r9 r: ri r rP rb rN rg r_ rk rn ro rp rq r{ r� r� r( r( r( r) r; d s, � �
r; c @ s: e Zd ZdZd
dd�Zdd� Zdd� Zd d
� Zd d � ZdS )� ExistingPackz>An in memory proxy for an existing .pack and its disk indices.Nc C s> t �| |||||� || _|| _d||||||fv r:t� �dS )z�Create an ExistingPack object.
:param pack_transport: The transport where the pack file resides.
:param name: The name of the pack on disk in the pack_transport.
N)r; r re rM �AssertionError)r$ rM re rH rI r! rJ rK r( r( r) r � s ��zExistingPack.__init__c C s | j |j kS rS )�__dict__r r( r( r) �__eq__� s zExistingPack.__eq__c C s | � |� S rS )r� r r( r( r) �__ne__� s zExistingPack.__ne__c C s" d| j j| j jt| �| j| jf S )Nz <%s.%s object at 0x%x, %s, %s)� __class__r8 r7 r~ rM re rO r( r( r) �__repr__� s �zExistingPack.__repr__c C s t t| �| jf�S rS )r� r� re rO r( r( r) r� s zExistingPack.__hash__)N) r7 r8 r9 r: r r� r� r� r� r( r( r( r) r� � s �
r� c @ s6 e Zd Zd dd�Zdd� Zdd� Zdd � Zd
d � ZdS )
� ResumedPackNc
C s� t j| |||||||
d� || _|| _g d�| _d|fd|fd|fd|fg} |
durn| �d|
f� | j�d� | D ] \} }
| �| �}|
j| j|< qr| j| _ | | _
d | _ dS )
z Create a ResumedPack object.�rK �NNNNrD rE rF rG NrC �resumed) r� r �upload_transportrv rw �appendrk Z_size� _index_classru r �_state)r$ re rH rI r! rJ r� rM rv �pack_collectionrK �indicesrj r` �offsetr( r( r) r s* �
�
zResumedPack.__init__c C s: | j dkrt�| �S | j dkr,| j| �� fS t| j ��d S )N�finishedr� )r� r; rP r� rN r� rO r( r( r) rP ! s
zResumedPack.access_tuplec C sV | j �| �� � | j| j| j| jg}| jd ur:|�| j� |D ]}|j �|j
� q>d S rS ) r� �deleterN rH rI r! rJ rK r� Z
_transport�_name)r$ r� r` r( r( r) �abort) s �
zResumedPack.abortc C s� | � � g d�}| jd ur$|�d� |D ]2}| �|| j�}d| }| j�||� | �|� q(d| �� }| j�| �� |� d| _ d S )N)rD rE rF rG rC z ../indices/� ../packs/r� )
rb rK r� r_ re r� �mover{ rN r� )r$ Z index_typesrj Zold_name�new_namer( r( r) �finish2 s
zResumedPack.finishc C s
|� d�S )z�Return compression parents for this index that are not present.
This returns any compression parents that are referenced by this index,
which are not contained *in* this index. They may be present elsewhere.
r0 )Zexternal_references�r$ r` r( r( r) rZ @ s z ResumedPack._get_external_refs)N)r7 r8 r9 r rP r� r� rZ r( r( r( r) r� s �
r� c @ sf e Zd ZdZddd�Zdd� Zdd � Zd
d � Zd d
� Zddd�Z dd� Z
dd� Z dd� Z ddd�Z
dS ) �NewPackz5An in memory proxy for a pack which is being created.� Nc sH |j }|jdur |dd�}nd}tj� |dd�|dd�|ddd�|dd�|d� |� _|j� _|j� _|j � _
|j � _ |� _
t�� � _d� _d� _t�d�| � _t�� � _� jj� j� j
d �� _d
tjv r�td t� � � jj � jt�� � j � g dg� _ d � j � jj � jj f� fd
d� }|� _!t"�#� j!�� _$� j$�%� d� _&d� _'dS )aM Create a NewPack instance.
:param pack_collection: A PackCollection into which this is being inserted.
:param upload_suffix: An optional suffix to be given to any temporary
files created during the pack creation. e.g '.autopack'
:param file_mode: Unix permissions for newly created file.
Nr )�reference_listsr0 r )r� Z key_elementsr� � ��mode�packz0%s: create_pack: pack stream open: %s%s t+%6.3fsFc sf |d � | � |d t| �7 < |d � jks4|rbd�|d �} || � || � g dg|d d �< d S )Nr r0 r. )r� �len� _cache_limit�join)�bytes�flush�_bufferZ_writeZ_updaterO r( r) � _write_data� s z%NewPack.__init__.<locals>._write_data�open)(�_index_builder_classrK r; r r r� ru �_upload_transportr� �_index_transportrv �_pack_transportrM �
_file_mode�osutilsZmd5�_hashrw r� Z
rand_chars� random_name�time�
start_time�open_write_stream� write_stream�debug� debug_flagsr �ctime�baser� �write�updater� r� ZContainerWriter�_writerZbeginr� re )r$ r� �
upload_suffix� file_mode�index_builder_classrK r� r( rO r) r L sN
�
�
�
�
zNewPack.__init__c C s" d| _ | j�� | j�| j� dS )zCancel creating this pack.ZabortedN)r� r� �closer� r� r� rO r( r( r) r� � s
z
NewPack.abortc C s8 | j dkrt�| �S | j dkr*| j| jfS t| j ��dS )rL r� r� N)r� r; rP r� r� r� rO r( r( r) rP � s
zNewPack.access_tuplec C s> t | �� p:| j�� p:| j�� p:| j�� p:| jduo:| j�� �S )z)True if data has been added to this pack.N)�boolrg rI rf r! rJ rK rO r( r( r) �
data_inserted� s
����zNewPack.data_insertedc C s@ | j d urd S | j�� | jd r0| jddd� | j�� | _ d S )Nr0 r. T)r� )re r� �endr� r� r� Z hexdigestrO r( r( r) �finish_content� s
zNewPack.finish_contentFc C s | � � |s| �� g d�| _| �d| jd|� | �d| jd|� | �d| jd|� | �d| jd|� | jdur�| j� d� | �d | jd
|� | j
j | j j
�d �d � | jd
}|s�d| }| j�| j|� d| _dtjv �rtdt�� | jj| j|t�� | j � dS )a= Finish the new pack.
This:
- finalises the content
- assigns a name (the md5 of the content, currently)
- writes out the associated indices
- renames the pack into place.
- stores the index size tuple for the pack in the index_sizes
attribute.
r� rD rE rF z
file textsrG zrevision signaturesNrC zcontent hash bytes�repository.fdatasync�Zwant_fdatasyncrc r� r� r� z1%s: create_pack: pack finished: %s%s->%s t+%6.3fs)r� rb rw � _write_indexrH rI r! rJ rK r� r� r� r � config_stack�getre r� r� r� r� r� r� r r� r� r� r� )r$ �suspendr� r( r( r) r� � s@
� �
�
� �
�zNewPack.finishc C sH | j d rDd�| j d �}| j�|� | j�|� g dg| j dd�< dS )zFlush any current data.r0 r. r N)r� r� r� r� r� r� )r$ r� r( r( r) r� s
z
NewPack.flushc C s |� � S rS )Z_external_referencesr� r( r( r) rZ
s zNewPack._get_external_refsc C s
|| _ d S rS )r� )r$ �sizer( r( r) �set_write_cache_size
s z NewPack.set_write_cache_sizec
C s� | � || j�}|r| j}n| j}|�� }|�� }|j|| jd�} | �|� | j | j
j � d�d� t
|�| j| �|�< dtjv r�tdt�� || jj| jt�� | j � | �|� dS )z�Write out an index.
:param index_type: The type of index to write - e.g. 'revision'.
:param index: The index object to serialise.
:param label: What label to give the index e.g. 'revision'.
r� r� r� r� z.%s: create_pack: wrote %s index: %s%s t+%6.3fsN)r_ re r� rv r� �readr� r� r� r� r r� r� r� rw rk r� r� r r� r� r� r� r� r{ )
r$ rj r` Zlabelr� r_ � transportZindex_tempfileZ index_bytesr� r( r( r) r� s( �
�
�zNewPack._write_index)r� N)F)F)r7 r8 r9 r: r r� rP r� r� r� r� rZ r� r� r( r( r( r) r� I s
^
7r� c @ s: e Zd ZdZd
dd�Zdd� Zdd� Zd d
� Zd d � ZdS )�AggregateIndexa� An aggregated index for the RepositoryPackCollection.
AggregateIndex is reponsible for managing the PackAccess object,
Index-To-Pack mapping, and all indices list for a specific type of index
such as 'revision index'.
A CombinedIndex provides an index on a single key space built up
from several on-disk indices. The AggregateIndex builds on this
to provide a knit access layer, and allows having up to one writable
index within the collection.
Nc C s6 || _ i | _tg |d�| _t| j||d�| _d| _dS )z�Create an AggregateIndex.
:param reload_func: A function to call if we find we are missing an
index. Should have the form reload_func() => True if the list of
active pack files has changed.
�� reload_func)r� �
flush_funcN)� _reload_func�
index_to_packZCombinedGraphIndexr" �_DirectPackAccess� data_access� add_callback)r$ r� r� r( r( r) r ? s �zAggregateIndex.__init__c C s$ |� � | j|< | j�d||j� dS )a Add index to the aggregate, which is an index for Pack pack.
Future searches on the aggregate index will seach this new index
before all previously inserted indices.
:param index: An Index for the pack.
:param pack: A Pack instance.
r N)rP r� r" Z insert_indexre �r$ r` r� r( r( r) � add_indexN s
zAggregateIndex.add_indexc C sJ | j dur td| | j f ��| �||� | j�|j||�� � |j| _ dS )a Add an index which is able to have data added to it.
There can be at most one writable index at any time. Any
modifications made to the knit are put into this index.
:param index: An index from the pack parameter.
:param pack: A Pack instance.
Nz*%s already has a writable index through %s)r� r� r� r� �
set_writerr� rP � add_nodesr� r( r( r) �add_writable_index\ s
�� z!AggregateIndex.add_writable_indexc C s@ | j �ddd� | j�� | jjdd�= | jjdd�= d| _dS )z(Reset all the aggregate data to nothing.N�NN)r� r� r� �clearr" �_indices� _index_namesr� rO r( r( r) r� o s
zAggregateIndex.clearc C s` | j |= | jj�|�}| jj|= | jj|= | jdur\t|dd�| jkr\d| _| j�ddd� dS )zwRemove index from the indices used to answer queries.
:param index: An index from the pack parameter.
Nr� r� ) r� r" r� r` r� r� �getattrr� r� )r$ r` �posr( r( r) � remove_indexw s
�zAggregateIndex.remove_index)NN) r7 r8 r9 r: r r� r� r� r� r( r( r( r) r� 0 s
r� c @ s\ e Zd ZdZddd�Zddd�Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dS )�PackerzCreate a pack from packs.Nc C s4 || _ || _|| _d| _|| _|| _d| _d| _dS )a Create a Packer.
:param pack_collection: A RepositoryPackCollection object where the
new pack is being written to.
:param packs: The packs to combine.
:param suffix: The suffix to use on the temporary files for the pack.
:param revision_ids: Revision ids to limit the pack to.
:param reload_func: A function to call if a pack file/index goes
missing. The side effect of calling this function should be to
update self.packs. See also AggregateIndex
N)�packs�suffixr4 �new_packr r� Z_revision_keysZ _text_filter)r$ r� r� r� r4 r� r( r( r) r � s
zPacker.__init__c C s� | j jdur t�d| jjf ��| jdur^t| j�dkr<dS t| j�| _tdd� | jD ��| _ |du rtt
j � � | _
n|| _
z | �� W |du r�| j
�� S n|du r�| j
�� 0 dS )a| Create a new pack by reading data from other packs.
This does little more than a bulk copy of data. One key difference
is that data with the same item key across multiple packs is elided
from the output. The new pack is written into the current pack store
along with its indices, and the name added to the pack names. The
source packs are not altered and are not required to be in the current
pack collection.
:param pb: An optional progress bar to use. A nested bar is created if
this is None.
:return: A Pack object, or None if nothing was copied.
Nz6call to %s.pack() while another pack is being written.r c s s | ] }|fV qd S rS r( )r* Zrevidr( r( r) rX � r. z Packer.pack.<locals>.<genexpr>)r � _new_packr �BzrErrorr� r7 r4 r� � frozensetZ
revision_keysZuiZ
ui_factoryZnested_progress_bar�pb�_create_pack_from_packsr� )r$ r� r( r( r) r� � s. �
�
� �z Packer.packc C s\ | j j| j | j| j jj�� d�}|jjdd� |jjdd� |j jdd� |j
jdd� |S )z)Open a pack for the pack we are creating.�r� r� F�Zcombine_backing_indices) r � pack_factoryr� �repo�
controldir�_get_file_moderH � set_optimizerI r! rJ �r$ r� r( r( r) � open_pack� s
�zPacker.open_packc C s t | j��dS )z#Copy revision data to the new pack.N)�NotImplementedError�_copy_revision_textsrO r( r( r) r� � s zPacker._copy_revision_textsc C s t | j��dS )z�Copy the inventory texts to the new pack.
self._revision_keys is used to determine what inventories to copy.
Sets self._text_filter appropriately.
N)r� �_copy_inventory_textsrO r( r( r) r� � s z Packer._copy_inventory_textsc C s t | j��d S rS )r� �_copy_text_textsrO r( r( r) r� � s zPacker._copy_text_textsc C s t | j��d S rS )r� r� rO r( r( r) r� � s z Packer._create_pack_from_packsc C sB dt jv r>tdt�� | jjj| jj | jj
� � t�� | jj � d S )Nr� z:%s: create_pack: file texts copied: %s%s %d items t+%6.3fs)
r� r� r r� r� r r� r� r� r� r! rf r� rO r( r( r) �_log_copied_texts� s
�zPacker._log_copied_textsc C s |� � S )z�Return True if new_pack should be used.
:param new_pack: The pack that has just been created.
:return: True if the pack should be used.
)r� r� r( r( r) � _use_pack� s zPacker._use_pack)NN)N)
r7 r8 r9 r: r r� r� r� r� r� r� r� r r( r( r( r) r� � s �
(
r� c @ s� e Zd ZdZdZdZdZdZdd� Zdd� Z dd� Z
d d
� Z d d � Z d
d� Z
dZdd�Zdd� Zdd� Zdd� Zd[dd�Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd\d*d+�Zd,d-� Z d.d/� Z d0d1� Z d2d3� Z d4d5� Z d6d7� Z!d]d8d9�Z"d:d;� Z#d<d=� Z$d>d?� Z%d@dA� Z&d^dBdC�Z'dDdE� Z(dFdG� Z)dHdI� Z*d_dJdK�Z+dLdM� Z,dNdO� Z-dPdQ� Z.dRdS� Z/dTdU� Z0dVdW� Z1dXdY� Z2dS )`�RepositoryPackCollectionzbManagement of packs within a repository.
:ivar _names: map of {pack_name: (index_size,)}
Nc
C s || _ || _|| _|| _|| _|| _|| _dddddd�| _g | _d| _ i | _
d| _ d| _ | j
} t| j| �| _t| j| �| _t| j| �| _t| j| �| _| j| j| j| jg}
|r�t| j| �| _|
�| j� nd| _dd � |
D �} | D ]} | �t| ��| g�� q�g | _t�| jj �| _ dS )
ay Create a new RepositoryPackCollection.
:param transport: Addresses the repository base directory
(typically .bzr/repository/).
:param index_transport: Addresses the directory containing indices.
:param upload_transport: Addresses the directory into which packs are written
while they're being created.
:param pack_transport: Addresses the directory of existing complete packs.
:param index_builder_class: The index builder class to use.
:param index_class: The index class to use.
:param use_chk_index: Whether to setup and manage a CHK index.
r r0 r rB r= )r> r? r@ rA r< Nc S s g | ]
}|j �qS r( )r" )r* Zagg_idxr( r( r) r- 9 r. z5RepositoryPackCollection.__init__.<locals>.<listcomp>) r� r� r� r� r� r� r� �_suffix_offsetsr� �_names�_packs_by_name�_packs_at_loadr� �_flush_new_packr� �reload_pack_namesrH rI r! rJ rK r� Zset_sibling_indices�setr[ �_resumed_packsr' Z
LocationStackr� r� )
r$ r� r� rv r� rM r� ru Z
use_chk_indexr� Z all_indicesZ all_combinedZ combined_idxr( r( r) r sD ���z!RepositoryPackCollection.__init__c C s d| j j| jf S )Nz%s(%r))r� r7 r� rO r( r( r) r� A s z!RepositoryPackCollection.__repr__c C s� |j | jv r td|j f ��| j�|� || j|j < | j�|j|� | j�|j|� | j�|j|� | j �|j |� | j
dur�| j
�|j
|� dS )zpMake a Pack object available to the repository to satisfy queries.
:param pack: A Pack object.
z!pack %s already in _packs_by_nameN) re r r� r� r� rH r� rI r! rJ rK �r$ r� r( r( r) �add_pack_to_memoryD s
�
z+RepositoryPackCollection.add_pack_to_memoryc C s& g }| � � D ]}|�| �|�� q |S )z�Return a list of all the Pack objects this repository has.
Note that an in-progress pack being created is not returned.
:return: A list of Pack objects for all the packs in the repository.
)�namesr� �get_pack_by_name)r$ �resultre r( r( r) � all_packsU s z"RepositoryPackCollection.all_packsc C s& z
| � � W S tjy Y q 0 q dS )a� Pack the pack collection incrementally.
This will not attempt global reorganisation or recompression,
rather it will just ensure that the total number of packs does
not grow without bound. It uses the _max_pack_count method to
determine if autopacking is needed, and the pack_distribution
method to determine the number of revisions in each pack.
If autopacking takes place then the packs name collection will have
been flushed to disk - packing requires updating the name collection
in synchronisation with certain steps. Otherwise the names collection
is not flushed.
:return: Something evaluating true if packing took place.
N)� _do_autopackr �
RetryAutopackrO r( r( r) �autopacka s
z!RepositoryPackCollection.autopackc C s� | j j�� }t| j�}| �|�|kr(d S | �|�}g }| �� D ]$}|�� }|dkrTq>|� ||f� q>| �
||�}t|�}t dd� |D ��} t dd� |D ��}
t dt
| �||| ||
� | j|| j| jd�} t dt
| �� | S )Nr c S s g | ]}t |d ��qS r/ )r� �r* Zpor( r( r) r- � r. z9RepositoryPackCollection._do_autopack.<locals>.<listcomp>c S s g | ] }|d �qS �r r( r r( r( r) r- � r. z}Auto-packing repository %s, which has %d pack files, containing %d revisions. Packing %d files into %d affecting %d revisions�� packer_classr� z$Auto-packing repository %s completed)rH r" rf r� r �_max_pack_count�pack_distributionr rg r� �plan_autopack_combinations�sumr �str�_execute_pack_operations�normal_packer_class�_restart_autopack) r$ �total_revisions� total_packsr �existing_packsr� �revision_count�pack_operationsZ
num_new_packsZ
num_old_packsZnum_revs_affectedr r( r( r) r y s:
���
�z%RepositoryPackCollection._do_autopackc C s� |D ]�\}}t |�dkrq|| |d|d�}z |�� }W n* tjy` |jdurZ|j�� � Y n0 |du rp dS |D ]}| �|� qtqg } |D ]\}
}| �|� q�| jd| d�}|S )z�Execute a series of pack operations.
:param pack_operations: A list of [revision_count, packs_to_combine].
:param packer_class: The class of packer to use
:return: The new pack names.
r z .autopackr� NT)�clear_obsolete_packs�obsolete_packs) r� r� r �RetryWithNewPacksr� r� �_remove_pack_from_memory�extend�_save_pack_names) r$ r# r r� r" r� Zpackerr r� Zto_be_obsoleted�_r( r( r) r � s. �
�z1RepositoryPackCollection._execute_pack_operationsc C s | j d ur| j �� d S rS )r� r� rO r( r( r) r � s
z(RepositoryPackCollection._flush_new_packc C s | j j�� dS )z�Acquire the mutex around the pack-names index.
This cannot be used in the middle of a read-only transaction on the
repository.
N)r� �
control_files�
lock_writerO r( r( r) �
lock_names� s z#RepositoryPackCollection.lock_namesc C s | j jjpt| j�dk S )z!Is the collection already packed?r0 )r� �_formatZpack_compressesr� r rO r( r( r) �_already_packed� s z(RepositoryPackCollection._already_packedFc C sx | � � t| j�}| �� r dS | jj�� }tdt| �|||� z| � |� W qh t
yb Y q>Y qh0 qhq>|rt| � � dS )z!Pack the pack collection totally.NzUPacking repository %s, which has %d pack files, containing %d revisions with hint %r.) �
ensure_loadedr� r r/ rH r" rf r r �_try_pack_operations�RetryPackOperations�_clear_obsolete_packs)r$ �hint�clean_obsolete_packsr r r( r( r) r� � s
�
z RepositoryPackCollection.packc C sl dg gg}| � � D ]@}|du s(|j|v r|d d |�� 7 < |d d �|� q| j|| j| jd� dS )z\Calculate the pack operations based on the hint (if any), and
execute them.
r N���r0 r )r re rg r� r �optimising_packer_class�_restart_pack_operations)r$ r4 r# r� r( r( r) r1 � s
�z-RepositoryPackCollection._try_pack_operationsc
C s t |�t |�krg S |jdd� dg gg}t |�r�|�d�\}}||d kr~|dkr�||d 8 }|dkrp|d= qL| |d< qLq*|d d |7 < |d d �|� |d d |d kr*|d= |�dg g� q*d}g }|D ]\}} ||7 }|�| � q�t |�dk�rtd��g S ||ggS )z�Plan a pack operation.
:param existing_packs: The packs to pack. (A list of (revcount, Pack)
tuples).
:param pack_distribution: A list with the number of revisions desired
in each pack.
T)�reverser r6 r0 zEWe somehow generated an autopack with a single pack file being moved.)r� �sort�popr� r( r� )
r$ r! r r# Znext_pack_rev_countZ next_packZfinal_rev_countZfinal_pack_listZnum_revsZ
pack_filesr( r( r) r � s4
z3RepositoryPackCollection.plan_autopack_combinationsc C s� | j �� st�| j ��| jdu rvi | _t� | _| �� D ]8\}}}|d �d�}| � |�| j|< | j�
||f� q6d}nd}| � � |S )ztEnsure we have read names from disk.
:return: True if the disk names had not been previously read.
Nr �asciiTF) r� � is_lockedr ZObjectNotLockedr r r �_iter_disk_pack_index�decode�_parse_index_sizes�addr )r$ r` r2 �valuere r r( r( r) r0 / s
z&RepositoryPackCollection.ensure_loadedc C s t dd� |�d�D ��S )z Parse a string of index sizes.c s s | ]}t |�V qd S rS )�int)r* �digitsr( r( r) rX H r. z>RepositoryPackCollection._parse_index_sizes.<locals>.<genexpr>� )�tuple�split)r$ rB r( r( r) r@ F s z+RepositoryPackCollection._parse_index_sizesc C s� z | j | W S ty� | �|d�}| �|d�}| �|d�}| �|d�}| jdurf| j|ddd�}nd}t| j||||||�}| �|� | Y S 0 dS ) z~Get a Pack object by name.
:param name: The name of the pack - e.g. '123456'
:return: A Pack object.
r> r? r@ rA Nr< T)�is_chk)r �KeyError� _make_indexrK r� r� r )r$ re � rev_index� inv_index� txt_index� sig_indexrK r r( r( r) r
J s
�
z)RepositoryPackCollection.get_pack_by_namec C s t �d|�s t�| j|gd��z�| j|ddd�}| j|ddd�}| j|ddd�}| j|ddd�}| jd ur~| j|d
ddd �}nd }| j|||||| j| j | j
| |d �
}W n< tj y� } z"t�| j|gt |���W Y d }~n
d }~0 0 | �
|� | j�|� |S )
z�Get a suspended Pack object by name.
:param name: The name of the pack - e.g. '123456'
:return: A Pack object.
z [a-f0-9]{32}zMalformed write group tokenr> T)�resumer? r@ rA Nr< )rO rH r� )�re�matchr �UnresumableWriteGroupr� rJ rK �resumed_pack_factoryr� r� r� �
NoSuchFiler r r r� ) r$ re rK rL rM rN rK r �er( r( r) � _resume_pack` s0
�
�
�
,
z%RepositoryPackCollection._resume_packc C sH | � � |j| jv r(t�d|j| f ��t|j�| j|j< | �|� dS )z�Allocate name in the list of packs.
:param a_new_pack: A NewPack instance to be added to the collection of
packs for this repository.
z Pack %r already exists in %sN)r0 re r r r� rF rw r )r$ Z
a_new_packr( r( r) �allocate s �z!RepositoryPackCollection.allocatec C s | � | jdd��� S )z�Iterate over the contents of the pack-names index.
This is used when loading the list from disk, and before writing to
detect updates from others during our write operation.
:return: An iterator of the index contents.
�
pack-namesN)r� r� Ziter_all_entriesrO r( r( r) r> � s z.RepositoryPackCollection._iter_disk_pack_indexc
C sl | j | }|| }|r*| j}|�|�j}n| j}| j| | }| j||||d�} |rh| jtju rhtj | _
| S )Nrr ) r r� �stat�st_sizer� r r� r ZBTreeGraphIndexrx ry )
r$ re r� rO rH Z size_offsetr_ r� Z
index_sizer` r( r( r) rJ � s
�z$RepositoryPackCollection._make_indexc C s. |sdS t |�}d}|D ]}|t|�7 }q|S )z�Return the maximum number of packs to use for total revisions.
:param total_revisions: The total number of revisions in the
repository.
r0 r )r rC )r$ r rD r Zdigitr( r( r) r � s z(RepositoryPackCollection._max_pack_countc C s t | j�� �S )z)Provide an order to the underlying names.)r\ r r5 rO r( r( r) r � s z RepositoryPackCollection.namesc C sJ |D �]>}zxz |j �|�� d|�� � W nT tjy~ z|j �d� W n tjy^ Y n0 |j �|�� d|�� � Y n0 W n: tjtjfy� } zt d|f � W Y d}~n
d}~0 0 g d�}| j
dur�|� d� |D ]d}z"| j �|j
| d|j
| � W q� tjtjf�y@ } zt d|f � W Y d}~q�d}~0 0 q�qdS )a� Move a number of packs which have been obsoleted out of the way.
Each pack and its associated indices are moved out of the way.
Note: for correctness this function should only be called after a new
pack names index has been written without these pack names, and with
the names of packs that contain the data previously available via these
packs.
:param packs: The packs to obsolete.
:param return: None.
z../obsolete_packs/z.couldn't rename obsolete pack, skipping it:
%sN)r? rA r@ r> r< z/couldn't rename obsolete index, skipping it:
%s)rM r� rN r rT �mkdirZ
FileExists� PathError�TransportErrorr rK r� r� re )r$ r� r� rU �suffixesr� r( r( r) �_obsolete_packs� s<
�
��
��z(RepositoryPackCollection._obsolete_packsc C s` |dkrdgS t t|��}g }t|�D ],\}}d| }tt|��D ]}|�|� qBq&tt |��S )z�Generate a list of the number of revisions to put in each pack.
:param total_revisions: The total number of revisions in the
repository.
r �
)�reversedr � enumerate�rangerC r� r] )r$ r rD r Zexponent�countr� r� r( r( r) r � s z*RepositoryPackCollection.pack_distributionc C s | j |d fS )z@Return a tuple with the transport and file name for a pack name.rc )r� rm r( r( r) � _pack_tuple� s z$RepositoryPackCollection._pack_tuplec C s6 | j �|j� | j�|j� | �|� | j�|� dS )z�Remove pack from the packs accessed by this repository.
Only affects memory state, until self._save_pack_names() is invoked.
N)r r; re r �_remove_pack_indicesr� �remover
r( r( r) r' � s
z1RepositoryPackCollection._remove_pack_from_memoryc C s` t jD ]T}|d }t| |�}|durt||�}z|�|� W q tyX |rRY q� Y q0 qdS )z�Remove the indices for pack from the aggregated indices.
:param ignore_missing: Suppress KeyErrors from calling remove_index.
rt N)r; ri r� r� rI )r$ r� �ignore_missingrj Z attr_nameZaggregate_indexZ
pack_indexr( r( r) rf s
z-RepositoryPackCollection._remove_pack_indicesc C s^ | j �� | j�� | j�� | j�� | jdur<| j�� d| _d| _g | _i | _ d| _
dS )zClear all cached data.N) rH r� rJ r! rI rK r� r r� r r rO r( r( r) �reset s
z RepositoryPackCollection.resetc C s | j j�� dS )z.Release the mutex around the pack-names index.N)r� r+ �unlockrO r( r( r) �
_unlock_names( s z&RepositoryPackCollection._unlock_namesc C s� t � }| �� D ]"\}}}|�|d �d�|f� qt |�}t � }t| j�D ]&\}}|�|d�dd� |D ��f� qJ| j| } || j }
|�| � |� |
� || |
|fS )aW Read the pack names from disk, and compare it to the one in memory.
:return: (disk_nodes, deleted_nodes, new_nodes)
disk_nodes The final set of nodes that should be referenced
deleted_nodes Nodes which have been removed from when we started
new_nodes Nodes that are newly introduced
r r< rE c s s | ]}d | V qdS )s %dNr( )r* r� r( r( r) rX > r. z<RepositoryPackCollection._diff_pack_names.<locals>.<genexpr>)
r r> rA r? r r r� r �difference_updater� ) r$ �
disk_nodesr` r2 rB �orig_disk_nodesZ
current_nodesre �sizes�
deleted_nodes� new_nodesr( r( r) �_diff_pack_names, s �
z)RepositoryPackCollection._diff_pack_namesc
C s� g }g }g }t |�}| �� D ]$}|j|vr |�|j� | �|� q |D ]x\}}| �|�} || jv r�| | j| kr�| �| �|�� | | j|< | �|� |�|� qF| | j|< | �|� |�|� qF|||fS )a Given the correct set of pack files, update our saved info.
:return: (removed, added, modified)
removed pack names removed from self._names
added pack names added to self._names
modified pack names that had changed value
)�dictr re r� r' r@ r r
)
r$ rm �removed�added�modifiedZ new_namesr� re rB ro r( r( r) �&_syncronize_pack_names_from_disk_nodesM s(
z?RepositoryPackCollection._syncronize_pack_names_from_disk_nodesc s� g � | � � z�| �� }| �� \}}}}|D ] \}} |�|�d�f| � q*| jjd|�� | jj �
� d� || _ |r�d}
|r�dd� |D �}
| � |
�� W | �
� n
| �
� 0 | �|� |rЇ fdd�|D �}| �|� d d� |D �S )
aN Save the list of packs.
This will take out the mutex around the pack names list for the
duration of the method call. If concurrent updates have been made, a
three-way merge between the current list and the current in memory list
is performed.
:param clear_obsolete_packs: If True, clear out the contents of the
obsolete_packs directory.
:param obsolete_packs: Packs that are obsolete once the new pack-names
file has been written.
:return: A list of the names saved that were not previously on disk.
r< rX r� Nc S s h | ]
}|j �qS r( rd �r* �or( r( r) r3 � r. z<RepositoryPackCollection._save_pack_names.<locals>.<setcomp>c s g | ]}|j � vr|�qS r( rd rx �Zalready_obsoleter( r) r- � s
�z=RepositoryPackCollection._save_pack_names.<locals>.<listcomp>c S s g | ] }|d �qS r r( )r* Znew_noder( r( r) r- � r. )r- r� rr Zadd_node�encoder� Zput_filer� r� r� r� r r3 rk rw r_ ) r$ r$ r% �builderrm rp rq rn re rB Z to_preserver( rz r) r) x s0 �
�
z)RepositoryPackCollection._save_pack_namesc C sJ | � � }|rdS | �� \}}}}|| _| �|�\}}}|sB|sB|rFdS dS )aK Sync our pack listing with what is present in the repository.
This should be called when we find out that something we thought was
present is now missing. This happens when another process re-packs the
repository, etc.
:return: True if the in-memory list of packs has been altered at all.
TF)r0 rr r rw ) r$ Z
first_readrm rp rq rn rt ru rv r( r( r) r � s �� z*RepositoryPackCollection.reload_pack_namesc C s" | � � s
� t�| jdt�� ��dS �z:Reload the pack names list, and restart the autopack code.FN)r r r r� �sys�exc_inforO r( r( r) r � s z*RepositoryPackCollection._restart_autopackc C s | � � s
� t| jdt�� ��dS r} )r r2 r� r~ r rO r( r( r) r8 � s z1RepositoryPackCollection._restart_pack_operationsc C s� g }| j �d�}|du r t� }z|�d�}W n tjyD | Y S 0 |D ]x}t�|�\}}|dkrn|�|� ||v rxqJz|� |� W qJ tj
tj fy� } zt d|f � W Y d}~qJd}~0 0 qJ|S )z�Delete everything from the obsolete-packs directory.
:return: A list of pack identifiers (the filename without '.pack') that
were found in obsolete_packs.
r% N�.rc z.couldn't delete obsolete pack, skipping it:
%s)
r� Zcloner Zlist_dirr rT r� �splitextr� r� r\ r] r ) r$ Zpreserve�foundZobsolete_pack_transportZobsolete_pack_files�filenamere ZextrU r( r( r) r3 � s*
� z.RepositoryPackCollection._clear_obsolete_packsc C s | j �� st�| ��| j| d| j j�� d�| _| j� | jj| j� | j
� | jj
| j� | j � | jj | j� | jj j dd� | j
� | jj
| j� | jd ur�| j� | jj| j� | jj| j jj_| jjj dd� | j
j| j jj_| jj| j jj_| j
j| j jj_| j j| j jj_d S )Nrc r� Fr� )r� �is_write_lockedr ZNotWriteLockedr� r� r� r� rH r� rI r! r� rJ rK r� Z chk_bytesrt Z
_add_callbackrR � revisions�
signaturesrQ rO r( r( r) �_start_write_group� s<
� � � � �
��z+RepositoryPackCollection._start_write_groupc C s� | j d ur`t�� �>}|�t| dd � |j| j| j dd� | j �� W d � n1 sV0 Y | jD ]F}t�� �*}|j| j|dd� |�� W d � qf1 s�0 Y qf| jd d �= d S )Nr� T)rh )r� Zcleanup� ExitStack�callbackrz rf r� r )r$ �stack� resumed_packr( r( r) �_abort_write_group
s
�(
�(z+RepositoryPackCollection._abort_write_groupc C s& | j D ]}| �|� q| j d d �= d S rS )r rf )r$ r� r( r( r) � _remove_resumed_pack_indices" s
z5RepositoryPackCollection._remove_resumed_pack_indicesc C s g S )z�Detect missing inventories in this write group.
:returns: list of strs, summarising any problems found. If the list is
empty no problems were found.
r( rO r( r( r) �_check_new_inventories' s z/RepositoryPackCollection._check_new_inventoriesc sP t � }d| jjfd| jjfd| jjfd| jjffD ](\� }|�� }|�� fdd�|D �� q2|rxt� d| jt
|�f ��| � � }|r�d� |�}t� d | ��| �
| j� d
}| j�� r�| j�� | �| j� d | _d }n| j�� d | _| jD ]0}d | j|j< | �|� |�� | �|� d }q�| jd d �= |�rL| �� }|�sH| �� S |S g S ) Nr� rR rQ r� c s g | ]}� f| �qS r( r( r1 ��prefixr( r) r- : r. z@RepositoryPackCollection._commit_write_group.<locals>.<listcomp>z3Repository %s has missing compression parent(s) %r �
z&Cannot add revision(s) to repository: FT)r r� r� rR rQ r� Z#get_missing_compression_parent_keysr� r r^ r\ r� r� rf r� r� r� rW r� r r re r' r r) ) r$ Z all_missingZversioned_filera ZproblemsZproblems_summaryZany_new_contentr� r r( r� r) �_commit_write_group1 sT
� ��
�
z,RepositoryPackCollection._commit_write_groupc C sf dd� | j D �}| �| j� | j�� rJ| jjdd� |�| jj� d | _n| j�� d | _| �� |S )Nc S s g | ]
}|j �qS r( rd )r* r� r( r( r) r- b r. zARepositoryPackCollection._suspend_write_group.<locals>.<listcomp>T)r� ) r rf r� r� r� r� re r� r� �r$ �tokensr( r( r) �_suspend_write_groupa s
z-RepositoryPackCollection._suspend_write_groupc C s |D ]}| � |� qd S rS )rV )r$ r� �tokenr( r( r) �_resume_write_groupo s z,RepositoryPackCollection._resume_write_group)N)NF)FF)F)FN)N)3r7 r8 r9 r: r� rS r r7 r r� r r r r r r r- r/ r� r1 r r0 r@ r
rV rW r> rJ r r r_ r re r' rf ri rk rr rw r) r r r8 r3 r� r� r� r� r� r� r� r( r( r( r) r � sb 9 ( �
%
4
-
!+
0
0r c @ s� e Zd ZdZdZdZdd� Zdd� Zdd� Zd d
� Z d d � Z
d
d� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd,dd �Zd d � Zd d � Zd!d"� Zd-d$d%�Zd.d&d'�Zd(d)� Zeejej �d*d+� �Z dS )/�PackRepositorya Repository with knit objects stored inside pack containers.
The layering for a KnitPackRepository is:
Graph | HPSS | Repository public layer |
===================================================
Tuple based apis below, string based, and key based apis above
---------------------------------------------------
VersionedFiles
Provides .texts, .revisions etc
This adapts the N-tuple keys to physical knit records which only have a
single string identifier (for historical reasons), which in older formats
was always the revision_id, and in the mapped code for packs is always
the last element of key tuples.
---------------------------------------------------
GraphIndex
A separate GraphIndex is used for each of the
texts/inventories/revisions/signatures contained within each individual
pack file. The GraphIndex layer works in N-tuples and is unaware of any
semantic value.
===================================================
Nc C sV t �| |||� || _|| _d| _| jjr<t�| � � �| _
n t�| �| _
| j
� � d S )NT) r
r �_commit_builder_class� _serializerZ _reconcile_fixes_text_parentsr. �supports_external_lookupsr ZCachingParentsProviderZ _make_parents_provider_unstacked�_unstacked_provider�
disable_cache)r$ r. � a_controldirr+ r� r� r( r( r) r � s � zPackRepository.__init__c C s@ | � � �$ dd� | j�� D �W d � S 1 s20 Y dS )z"See Repository.all_revision_ids().c S s g | ] }|d �qS r r( r1 r( r( r) r- � r. z4PackRepository._all_revision_ids.<locals>.<listcomp>N)� lock_readr� r5 rO r( r( r) �_all_revision_ids� s
z PackRepository._all_revision_idsc C s | j jj�� | j�� d S rS )r� rt �_key_dependenciesr� r r� rO r( r( r) r� � s z!PackRepository._abort_write_groupc C s$ | j js| jS t�t| jg| j��S rS )r. r� r� r ZStackedParentsProviderr �_fallback_repositoriesrO r( r( r) �_make_parents_provider� s
�z%PackRepository._make_parents_providerc C s. | � � s d S | j�� | j�� | j�� d S rS )r= r r r� r� � enable_cacherO r( r( r) �
_refresh_data� s
z PackRepository._refresh_datac C s | j �� d S rS )r r� rO r( r( r) r� � s z!PackRepository._start_write_groupc C s0 | j �� }| jjj�� | j�� | j�� |S rS ) r r� r� rt r� r� r� r� r� )r$ r4 r( r( r) r� � s
z"PackRepository._commit_write_groupc C s" | j �� }| jjj�� d | _|S rS )r r� r� rt r� r� � _write_groupr� r( r( r) �suspend_write_group� s
z"PackRepository.suspend_write_groupc C sZ | � � z| j�|� W n tjy6 | �� � Y n0 | jjD ]}| jj� |j
� q@d S rS ) r� r r� r rR r� r r� rt Zscan_unvalidated_indexrH )r$ r� r� r( r( r) r� � s z"PackRepository._resume_write_groupc C s | j r | jS | j�� S d S rS )�_write_lock_count� _transactionr+ �get_transactionrO r( r( r) r� � s z PackRepository.get_transactionc C s | j p| j�� S rS )r� r+ r= rO r( r( r) r= � s zPackRepository.is_lockedc C s | j S rS )r� rO r( r( r) r� � s z PackRepository.is_write_lockedc C s� | � � }| js |r t�| ��| jd7 _| jdkr>t�� | _|s�dtjv r`| j dkr`t
d| � d| _ | j � � | j
D ] }|�� qv| �� t| jd�S )ziLock the repository for writes.
:return: A breezy.repository.RepositoryWriteLockResult.
r0 �relock�wz%r was write locked againN)r= r� r Z
ReadOnlyErrorZ transactionsZWriteTransactionr� r� r� �
_prev_lockr r� r� r� r� r� r rj )r$ r� �lockedr� r( r( r) r, � s
zPackRepository.lock_writec C s� | � � }| jr | jd7 _n
| j�� |svdtjv rJ| jdkrJtd| � d| _| j� � | j
D ] }|�� q`| � � t | j
�S )zZLock the repository for reads.
:return: A breezy.lock.LogicalLockResult.
r0 r� rW z%r was read locked again)r= r� r+ r� r� r� r� r r� r� r� r� r
rj )r$ r� r� r( r( r) r� � s
zPackRepository.lock_readc C s t | j��d S rS )r� �leave_lock_in_placerO r( r( r) r�
s z"PackRepository.leave_lock_in_placec C s t | j��d S rS )r� �dont_leave_lock_in_placerO r( r( r) r� s z'PackRepository.dont_leave_lock_in_placeFc C s< | � � � | jj||d� W d � n1 s.0 Y dS )z�Compress the data within the repository.
This will pack all the data to a single pack. In future it may
recompress deltas or do other such expensive operations.
)r4 r5 N)r, r r� )r$ r4 r5 r( r( r) r� s
�zPackRepository.packc C sL ddl m} | �� �$ || |d�}|� � W d � S 1 s>0 Y dS )zReconcile this repository.r0 )�PackReconciler)�thoroughN)� reconciler� r, )r$ r� r� r� Z
reconcilerr( r( r) r� s
zPackRepository.reconcilec C s t | j��d S rS )r� �_reconcile_pack)r$ Z
collectionr� � extensionZrevsr� r( r( r) r� # s z PackRepository._reconcile_packc C s� | j dkr@| jd ur@| �� | j�� d | _d| _ t�d| ��| j rp| j d8 _ | j sz| j}d | _|�� n
| j �
� | � � s�| j�� | j D ] }|�
� q�d S )Nr0 r z6Must end write group before releasing write lock on %s)
r� r� Zabort_write_groupr� r� r� r r� r� r+ rj r= r� )r$ Z transactionr� r( r( r) rj & s*
��
zPackRepository.unlock)N)NF)NF) r7 r8 r9 r: r� r� r r� r� r� r� r� r� r� r� r� r= r� r, r� r� r� r� r� r� r r Z LockNotHeldZ
LockBrokenrj r( r( r( r) r� t s0
r� c @ sT e Zd ZdZdZdZdZdZdZdZ dZ
dZ dZ dZ
dZdZd dd�Zd
dd�ZdS ) �RepositoryFormatPacka� Format logic for pack structured repositories.
This repository format has:
- a list of packs in pack-names
- packs in packs/NAME.pack
- indices in indices/NAME.{iix,six,tix,rix}
- knit deltas in the packs, knit indices mapped to the indices.
- thunk objects to support the knits programming API.
- a format marker of its own
- an optional 'shared-storage' flag
- an optional 'no-working-trees' flag
- a LockDir lock
NTFc C sl t d|jj� g d�}| �� }d|�� fg}d| �� fg}| �|||||� | j|dd�}| �|||� |S )a Create a pack based repository.
:param a_controldir: bzrdir to contain the new repository; must already
be initialized.
:param shared: If true the repository will be initialized as a shared
repository.
zcreating repository in %s.)r� r% r� ZuploadrX �formatT)r� �_found) r r� r� r� r� Zget_format_stringZ_upload_blank_contentr� Z_run_post_repo_init_hooks)r$ r� Zshared�dirsr| �filesZ
utf8_filesr% r( r( r) �
initializef s
�z RepositoryFormatPack.initializec C sN |st �|�}|dur |}n
|�d�}t�|dtj�}| j| ||| j| j d�S )a See RepositoryFormat.open().
:param _override_transport: INTERNAL USE ONLY. Allows opening the
repository at a slightly different url
than normal. I.e. during 'upgrade'.
N�lock)r. r� r+ r� r� )
r Z find_formatZget_repository_transportr Z
LockableFilesr ZLockDir�repository_classr� r� )r$ r� r� Z_override_transportr� Zrepo_transportr+ r( r( r) r� z s
��zRepositoryFormatPack.open)F)FN)r7 r8 r9 r: r� r� r� Zsupports_ghostsr� Z
supports_chksr� ru Z_fetch_uses_deltasZ fast_deltasZsupports_funky_charactersZ%revision_graph_can_have_wrong_parentsr� r� r( r( r( r) r� ? s
r� c @ s e Zd ZdZdZdZdS )r2 z�Raised when we are packing and we find a missing file.
Meant as a signaling exception, to tell the RepositoryPackCollection.pack
code it should try again.
TzWPack files have changed, reload and try pack again. context: %(context)s %(orig_error)sN)r7 r8 r9 r: Zinternal_errorZ_fmtr( r( r( r) r2 � s r2 c @ sJ e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dS )r� z:Access to data in one or more packs with less translation.Nc C s" d| _ d| _|| _|| _|| _dS )a Create a _DirectPackAccess object.
:param index_to_packs: A dict mapping index objects to the transport
and file names for obtaining data.
:param reload_func: A function to call if we determine that the pack
files have moved and we need to reload our caches. See
breezy.repo_fmt.pack_repo.AggregateIndex for more details.
N)�_container_writerr� r� r� � _flush_func)r$ Zindex_to_packsr� r� r( r( r) r � s
z_DirectPackAccess.__init__c C s | j �||g �\}}| j||fS )a� Add raw knit bytes to a storage area.
The data is spooled to the container writer in one bytes-record per
raw data item.
:param key: key of the data segment
:param size: length of the data segment
:param raw_data: A bytestring containing the data.
:return: An opaque index memo For _DirectPackAccess the memo is
(index, pos, length), where the index field is the write_index
object supplied to the PackAccess object.
)r� Zadd_bytes_recordr� )r$ r2 r� �raw_dataZp_offsetZp_lengthr( r( r) �add_raw_record� s
�z _DirectPackAccess.add_raw_recordc C sh d� |�}t|t�s$tdt|� ��g }d}|D ]2\}}|�| �|||||| � g�� ||7 }q0|S )aM Add raw knit bytes to a storage area.
The data is spooled to the container writer in one bytes-record per
raw data item.
:param sizes: An iterable of tuples containing the key and size of each
raw data segment.
:param raw_data: A bytestring containing the data.
:return: A list of memos to retrieve the record later. Each memo is an
opaque index memo. For _DirectPackAccess the memo is (index, pos,
length), where the index field is the write_index object supplied
to the PackAccess object.
r. z data must be plain bytes was %sr )r� r| r� r� r� r� r� )r$ Z key_sizesr� r r� r2 r� r( r( r) �add_raw_records� s
� �
z!_DirectPackAccess.add_raw_recordsc C s | j dur| � � dS )zoFlush pending writes on this access object.
This will flush any buffered writes to a NewPack.
N)r� rO r( r( r) r� � s
z_DirectPackAccess.flushc c s0 g }d}|D ]F\}}}||kr.|� ||f� q |durD|� ||f� |}||fg}q |durj|� ||f� |D ]�\}}z| j| \} }
W n2 ty� | jdu r�� tj|dt�� d��Y n0 z.t� | |
|�} | �
� D ]\} }
|
d�V q�W qn tj �y( | jdu �r
� tj| � |
�dt�� d��Y qn0 qndS )aZ Get the raw bytes for a records.
:param memos_for_retrieval: An iterable containing the (index, pos,
length) memo for retrieving the bytes. The Pack access method
looks up the pack to use for a given record in its index_to_pack
map.
:return: An iterator over the bytes of the records.
NT)�reload_occurredr F)
r� r� rI r� r r& r~ r r� Zmake_readv_readerZ iter_recordsrT �abspath)r$ Zmemos_for_retrievalZ
request_listsZ
current_indexr` r� ZlengthZ current_listZoffsetsr� �path�readerr Z read_funcr( r( r) �get_raw_records� s@
� �z!_DirectPackAccess.get_raw_recordsc C s" |dur|| j |< || _|| _dS )z$Set a writer to use for adding data.N)r� r� r� )r$ �writerr` Ztransport_packnamer( r( r) r� s
z _DirectPackAccess.set_writerc C s8 d}| j du rd}n| � � s&|js&d}|r4t|j� dS )a� Try calling the reload function, or re-raise the original exception.
This should be called after _DirectPackAccess raises a
RetryWithNewPacks exception. This function will handle the common logic
of determining when the error is fatal versus being temporary.
It will also make sure that the original exception is raised, rather
than the RetryWithNewPacks exception.
If this function returns, then the calling function should retry
whatever operation was being performed. Otherwise an exception will
be raised.
:param retry_exc: A RetryWithNewPacks exception.
FNT)r� r� r r )r$ Z retry_excZis_errorr( r( r) �reload_or_raise s
z!_DirectPackAccess.reload_or_raise)NN) r7 r8 r9 r: r r� r� r� r� r� r� r( r( r( r) r� � s
2r� )/Z
__future__r rP r~ r �globalsr� r r r Zbzrr Z
decoratorsr r� r
r% r r Zbzr.repositoryr
r Zsixishr r Zbzr.vf_repositoryr r r Ztracer r r r �objectr; r� r� r� r� r� r r� r� r& r2 r� r( r( r( r) �<module> sB !E hVw } LQ