-=[ Mr. Bumblebee ]=-
_Indonesia_
:Nc @@ s d Z d d l m Z d d l m Z d d l m Z d d l Z d d l Z d d l m
Z
e
e d d d l m
Z
m Z m Z d d l m Z m Z m Z m Z m Z m Z d d
l m Z m Z m Z m Z d d l m Z m Z m Z m Z m! Z! m" Z" m# Z# d Z$ d
Z% d d d Z& d e' f d YZ( d e( f d YZ) d e( f d YZ* d e( f d YZ+ d e( f d YZ, d e( f d YZ- d e( f d YZ. d e! f d YZ/ d e! f d! YZ0 d" Z1 d# Z2 d$ e' f d% YZ3 d& e3 f d' YZ4 d( e3 f d) YZ5 d* e' f d+ YZ6 d, e6 f d- YZ7 d. e6 f d/ YZ8 d0 Z9 d1 Z: d2 Z; d3 Z< d4 e# f d5 YZ= d6 e' f d7 YZ> d8 e> f d9 YZ? d: e> f d; YZ@ d< e' f d= YZA d> e' f d? YZB d@ e' f dA YZC dB ZD dC e
jE f dD YZF y d dE lG mH ZI Wn0 eJ k
rZK e jL eK d dF lM mN ZI n Xd S(G sk Knit versionedfile implementation.
A knit is a versioned file implementation that supports efficient append only
updates.
Knit file layout:
lifeless: the data file is made up of "delta records". each delta record has a delta header
that contains; (1) a version id, (2) the size of the delta (in lines), and (3) the digest of
the -expanded data- (ie, the delta applied to the parent). the delta also ends with a
end-marker; simply "end VERSION"
delta can be line or full contents.a
... the 8's there are the index number of the annotation.
version robertc@robertcollins.net-20051003014215-ee2990904cc4c7ad 7 c7d23b2a5bd6ca00e8e266cec0ec228158ee9f9e
59,59,3
8
8 if ie.executable:
8 e.set('executable', 'yes')
130,130,2
8 if elt.get('executable') == 'yes':
8 ie.executable = True
end robertc@robertcollins.net-20051003014215-ee2990904cc4c7ad
whats in an index:
09:33 < jrydberg> lifeless: each index is made up of a tuple of; version id, options, position, size, parents
09:33 < jrydberg> lifeless: the parents are currently dictionary compressed
09:33 < jrydberg> lifeless: (meaning it currently does not support ghosts)
09:33 < lifeless> right
09:33 < jrydberg> lifeless: the position and size is the range in the data file
so the index sequence is the dictionary compressed sequence number used
in the deltas to provide line annotation
i ( t absolute_import( t StringIO( t izipN( t lazy_imports
import gzip
from bzrlib import (
debug,
diff,
graph as _mod_graph,
index as _mod_index,
pack,
patiencediff,
static_tuple,
trace,
tsort,
tuned_gzip,
ui,
)
from bzrlib.repofmt import pack_repo
from bzrlib.i18n import gettext
( t annotatet errorst osutils( t
NoSuchFilet InvalidRevisionIdt KnitCorruptt KnitHeaderErrort RevisionNotPresentt SHA1KnitCorrupt( t contains_whitespacet
sha_stringt sha_stringst split_lines( t _KeyRefst AbsentContentFactoryt adapter_registryt ConstantMappert ContentFactoryt sort_groupcompresst VersionedFilesWithFallbackss .knits .kndxi i t KnitAdapterc B@ s e Z d Z d Z RS( s$ Base class for knit record adaption.c C@ s7 t d d | _ t | _ t | _ | | _ d S( s Create an adapter which accesses full texts from basis_vf.
:param basis_vf: A versioned file to access basis texts of deltas from.
May be None for adapters that do not need to access basis texts.
N( t KnitVersionedFilest Nonet _datat KnitAnnotateFactoryt _annotate_factoryt KnitPlainFactoryt _plain_factoryt _basis_vf( t selft basis_vf( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt __init__ s ( t __name__t
__module__t __doc__R# ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s t FTAnnotatedToUnannotatedc B@ s e Z d Z d Z RS( s7 An adapter from FT annotated knits to unannotated ones.c C@ sm | j } | j j | \ } } | j j | | d } | j j | d f | d | j \ } } | S( Ni i ( t _raw_recordR t _parse_record_uncheckedR t parse_fulltextt _record_to_datat text( R! t factoryt annotated_compressed_bytest rect contentst contentt sizet bytes( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_bytes s
/( R$ R% R& R4 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR' s t DeltaAnnotatedToUnannotatedc B@ s e Z d Z d Z RS( s4 An adapter for deltas from annotated to unannotated.c C@ s | j } | j j | \ } } | j j | | d d t } | j j | } | j j | d f | d | \ } } | S( Ni t plaini ( R( R R) R t parse_line_deltat TrueR t lower_line_deltaR+ ( R! R- R. R/ R0 t deltaR2 R3 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR4 s )( R$ R% R& R4 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR5 s t FTAnnotatedToFullTextc B@ s e Z d Z d Z RS( s7 An adapter from FT annotated knits to unannotated ones.c C@ s_ | j } | j j | \ } } | j j | j d | | j d \ } } d j | j S( Nit (
R( R R) R t parse_recordt keyt _build_detailsR t joinR, ( R! R- R. R/ R0 R1 R: ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR4 s
( R$ R% R& R4 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR; s t DeltaAnnotatedToFullTextc B@ s e Z d Z d Z RS( s4 An adapter for deltas from annotated to unannotated.c C@ s | j } | j j | \ } } | j j | | d d t } | j d } | j j | g d t j } | j
d k r t j | | j n | j
d } t j | } t | | }
|
j | | d | j d |
_ d j |
j S( Ni R6 i t unorderedt absentt chunkedR< ( R( R R) R R7 R8 t parentsR t get_record_streamt nextt storage_kindR R t get_bytes_asR t chunks_to_linest PlainKnitContentt apply_deltaR? t _should_strip_eolR@ R, ( R! R- R. R/ R0 R: t compression_parentt basis_entryt basis_chunkst basis_linest
basis_content( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR4 s
( R$ R% R& R4 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRA s t FTPlainToFullTextc B@ s e Z d Z d Z RS( s3 An adapter from FT plain knits to unannotated ones.c C@ s_ | j } | j j | \ } } | j j | j d | | j d \ } } d j | j S( NiR< (
R( R R) R R= R> R? R R@ R, ( R! R- t compressed_bytesR/ R0 R1 R: ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR4 s
( R$ R% R& R4 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRS s t DeltaPlainToFullTextc B@ s e Z d Z d Z RS( s4 An adapter for deltas from annotated to unannotated.c
C@ s | j } | j j | \ } } | j j | | d } | j d } | j j | g d t j } | j
d k r t j | | j n | j
d } t j | } t | | }
| j j | d | | j |
\ } } d j | j S( Ni i RB RC RD R< ( R( R R) R R7 RE R RF R8 RG RH R R RI R RJ RK R= R? R@ R, (
R! R- RT R/ R0 R: RN RO RP RQ RR R1 t _( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR4 s
( R$ R% R& R4 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRU s t KnitContentFactoryc B@ s/ e Z d Z d d d Z d Z d Z RS( sL Content factory for streaming from knits.
:seealso ContentFactory:
c C@ s t j | | | _ | | _ | | _ | d d k rA d } n d } | rV d }
n d }
d |
| f | _ | | _ | | _ | | _ | | _ d S( s Create a KnitContentFactory for key.
:param key: The key.
:param parents: The parents.
:param build_details: The build details as returned from
get_build_details.
:param sha1: The sha1 expected from the full text of this object.
:param raw_record: The bytes of the knit data from disk.
:param annotated: True if the raw data is annotated.
:param network_bytes: None to calculate the network bytes on demand,
not-none if they are already known.
i s
line-deltaR: t fts
annotated-R< s knit-%s%s-gzN(
R R# t sha1R> RE RH R( t _network_bytesR? t _knit( R! R> RE t
build_detailsRY t
raw_recordt annotatedt knitt
network_bytest kindt annotated_kind( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s
c C@ s d j | j } | j d k r* d } n d j d | j D } | j d r\ d } n d } d | j | | | | j f } | | _ d S(
s; Create a fully serialised network version for transmission.t s None:s c s@ s | ] } d j | Vq d S( Rc N( R@ ( t .0R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr>! s i t Nt s
%s
%s
%s
%s%sN( R@ R> RE R R? RH R( RZ ( R! t key_bytest parent_bytest noeolR` ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _create_network_bytes s
c C@ s | | j k r2 | j d k r+ | j n | j Sd | j k r | d k r | j d f } t j | } | d } | j | } | d k r | g S| Sn | j d k r | d k r | j j | j d S| d k r | j j
| j d Sn t j | j | | j d S( Ns -ft-RD t fulltexti ( s chunkedRk (
RH RZ R Rj R t getR4 R[ t get_linesR> t get_textR t UnavailableRepresentation( R! RH t adapter_keyt adapter_factoryt adapterR3 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRI * s(
N( R$ R% R& R R# Rj RI ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRW s t LazyKnitContentFactoryc B@ s e Z d Z d Z d Z RS( sg A ContentFactory which can either generate full text or a wire form.
:seealso ContentFactory:
c C@ sS | | _ | | _ d | _ | | _ d | _ | sF | j d | _ n | | _ d S( s Create a LazyKnitContentFactory.
:param key: The key of the record.
:param parents: The parents of the record.
:param generator: A _ContentMapGenerator containing the record for this
key.
:param first: Is this the first content object returned from generator?
if it is, its storage kind is knit-delta-closure, otherwise it is
knit-delta-closure-ref
s knit-delta-closures -refN( R> RE R RY t
_generatorRH t _first( R! R> RE t generatort first( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# J s c C@ s | | j k r, | j r% | j j Sd Sn | d k rs | j j | j j } | d k rc | Sd j | Sn t j | j | | j d S( NR< RD Rk ( s chunkeds fulltext(
RH Ru Rt t _wire_bytest
_get_one_workR> R, R@ R Ro ( R! RH t chunks( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRI ^ s
( R$ R% R& R# RI ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRs D s c C@ s t | | } | j S( s Convert a network record to a iterator over stream records.
:param storage_kind: The storage kind of the record.
Must be 'knit-delta-closure'.
:param bytes: The bytes of the record on the network.
( t _NetworkContentMapGeneratorRF ( RH R3 t line_endRv ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt knit_delta_closure_to_recordsp s c
C@ s2 | } | j d | } t | | | !j d } | d } | j d | } | | | !} | d k rr d } n= t g | j d D]! } | r t | j d ^ q } | d } | | d k } d | k r d } n d } | | f }
| d } | | } d
| k } t | | |
d | | d | g S(
s Convert a network record to a record object.
:param storage_kind: The storage kind of the record.
:param bytes: The bytes of the record on the network.
s
Rc i s None:s Re RX Rk s
line-deltaR^ R` N( t findt tuplet splitR RW (
RH R3 R| t startR> t parent_lineRE t segmentRi t methodR\ R] R^ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt knit_network_to_record{ s,
$
t KnitContentc B@ sA e Z d Z d Z d Z d Z d Z e d Z RS( s Content of a knit version to which deltas can be applied.
This is always stored in memory as a list of lines with \n at the end,
plus a flag saying if the final ending is really there or not, because that
corresponds to the on-disk knit representation.
c C@ s
t | _ d S( N( t FalseRM ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s c C@ s t | j d S( s4 Apply delta to this object to become new_version_id.N( t NotImplementedErrorRL ( R! R: t new_version_id( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRL s c
c@ s | j } | j } t j d | | } xT | j D]F \ } } } } } | d k ra q: n | | | | | j | | !f Vq: Wd S( s9 Generate line-based delta from this content to new_lines.t equalN( R, t patiencedifft PatienceSequenceMatcherR t get_opcodest _lines(
R! t new_linest new_textst old_textst st tagt i1t i2t j1t j2( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt line_delta_iter s " c C@ s t | j | S( N( t listR ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt
line_delta s c c@ s7 t | } d } d } x | D] \ } } } } | | }
|
} | d k r | | | d | | | d k r~ | d 8} n | d k r | | | f Vq n | | |
7} | } q W| | } | d k r | | | d | | | d k r | d 8} n | d k r | | | f Vq n | | | | d f Vd S( s? Extract SequenceMatcher.get_matching_blocks() from a knit deltai i N( t len( t
knit_deltat sourcet targett
target_lent s_post t_post s_begint s_endt t_lent new_textt true_nt n( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_line_delta_blocks s(
$
$
( R$ R% R& R# RL R R t staticmethodR ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s t AnnotatedKnitContentc B@ s; e Z d Z d Z d Z d Z d Z d Z RS( s Annotated content.c C@ s t j | | | _ d S( N( R R# R ( R! t lines( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s
c C@ sC | j } | j r? | d \ } } | | j d f | d <n | S( s6 Return a list of (origin, text) for each content line.is
( R RM t rstrip( R! R t origint last_line( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c C@ sW d } | j } xA | D]9 \ } } } } | | | | | | +| | | | } q Wd S( s4 Apply delta to this object to become new_version_id.i N( R ( R! R: R t offsetR R t endt countt delta_lines( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRL s
c C@ sy y& g | j D] \ } } | ^ q
} Wn) t k
rQ } t | d | f n X| j ru | d j d | d <n | S( Ns9 line in annotated knit missing annotation information: %sis
( R t
ValueErrorR RM R ( R! R R, R t e( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR, s & c C@ s t | j S( N( R R ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt copy s ( R$ R% R& R# R RL R, R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s RK c B@ s; e Z d Z d Z d Z d Z d Z d Z RS( s Unannotated content.
When annotate[_iter] is called on this content, the same version is reported
for all lines. Generally, annotate[_iter] is not useful on PlainKnitContent
objects.
c C@ s# t j | | | _ | | _ d S( N( R R# R t _version_id( R! R t
version_id( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s
c C@ s# g | j D] } | j | f ^ q
S( s6 Return a list of (origin, text) for each content line.( R R ( R! t line( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s` d } | j } xA | D]9 \ } } } } | | | | | | +| | | | } q W| | _ d S( s4 Apply delta to this object to become new_version_id.i N( R R ( R! R: R R R R R R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRL
s c C@ s t | j | j S( N( RK R R ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s7 | j } | j r3 | } | d j d | d <n | S( Nis
( R RM R ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR, s
( R$ R% R& R# R RL R R, ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRK s t _KnitFactoryc B@ s e Z d Z e d Z RS( s( Base class for common Factory functions.c
C@ s | \ } } | d k rX | r- | j } n | } | j | | } | j | | n | j | | } d } | | _ | | f S( s Parse a record into a full content object.
:param version_id: The official version id for this content
:param record: The data returned by read_records_iter()
:param record_details: Details about the record returned by
get_build_details
:param base_content: If get_build_details returns a compression_parent,
you must return a base_content here, else use None
:param copy_base_content: When building from the base_content, decide
you can either copy it and return a new object, or modify it in
place.
:return: (content, delta) A Content object and possibly a line-delta,
delta may be None
s
line-deltaN( R R7 RL R* R RM (
R! R t recordt record_detailst base_contentt copy_base_contentR Ri R1 R: ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR= $ s ( R$ R% R& R8 R= ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR ! s R c B@ sh e Z d Z e Z d Z d Z d Z e d Z d Z
d Z d Z d Z
d Z RS(
s/ Factory for creating annotated Content objects.c C@ s& t | } t t | g | | S( N( R R t zip( R! R R t num_lines( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt makeH s c C@ s5 g | D] } t | j d d ^ q } t | S( s Convert fulltext to internal representation
fulltext content is of the format
revid(utf8) plaintext
internal representation is of the format:
(revid, plaintext)
Rf i ( R R R ( R! R1 R R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR* L s +c C@ s t | j | S( N( t iterR7 ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt parse_line_delta_iter[ s c @ sY g } t | } | j } i f d } | r x | D] } g | j d D] } t | ^ qS \ } }
} g t | D] } | j d d d ^ q }
| j | |
| |
f q= Wn x | D] } g | j d D] } t | ^ q \ } }
} g t | D]! } t | j d d ^ q}
| j | |
| |
f q W| S( s Convert a line based delta into internal representation.
line delta is in the form of:
intstart intend intcount
1..count lines:
revid(utf8) newline
internal representation is
(start, end, count, [1..count tuples (revid, newline)])
:param plain: If True, the lines are returned as a plain
list without annotations, not as a list of (origin, content) tuples, i.e.
(start, end, count, [1..count newline])
c @ s. | j d d \ } } j | | | f S( NRf i ( R t
setdefault( R R R, ( t cache( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt cache_and_returnq s t ,Rf i ( R RG R t intt xranget appendR ( R! R R R6 t resultRG R t headerR R R R t iR0 ( ( R s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR7 ^ s
12
14 c C@ s d | D S( s/ Extract just the content lines from a fulltext.c s@ s% | ] } | j d d d Vq d S( Rf i N( R ( Rd R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr> s ( ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_fulltext_content s c c@ s t | } | j } xd | D]\ } | j d } t | d } x4 t | D]& } | j d d \ } } | VqN Wq Wd S( s Extract just the content from a line delta.
This doesn't return all of the extra information stored in a delta.
Only the actual content lines.
R i Rf i N( R RG R R R ( R! R RG R R R R R, ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_linedelta_content s
c C@ s* g | j D] \ } } d | | f ^ q
S( st convert a fulltext content record into a serializable form.
see parse_fulltext which this inverts.
s %s %s( R ( R! R1 t ot t( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt lower_fulltext s c C@ sX g } xK | D]C \ } } } } | j d | | | f | j d | D q
W| S( sd convert a delta into a serializable form.
See parse_line_delta which this inverts.
s %d,%d,%d
c s@ s# | ] \ } } | d | Vq d S( Rf N( ( Rd R R, ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr> s ( R t extend( R! R: t outR R t cR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR9 s c C@ s | j | } t | t k rr | d } | j } g } x. | D]& \ } } | j | | f | f qD W| S| j Sd S( Ni( t _get_contentt typeR R R ( R! R_ R> R1 t prefixt originsR R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
( R$ R% R& R8 R^ R R* R R R7 R R R R9 R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR C s & R c B@ se e Z d Z e Z d Z d Z d Z d Z d Z d Z
d Z d Z d Z
RS(
s+ Factory for creating plain Content objects.c C@ s
t | | S( N( RK ( R! R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s | j | | S( s This parses an unannotated fulltext.
Note that this is not a noop - the internal representation
has (versionid, line) - its just a constant versionid.
( R ( R! R1 R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR* s c
c@ s d } t | } x{ | | k r | | } | d 7} g | j d D] } t | ^ qE \ } } } | | | | | | | !f V| | 7} q Wd S( Ni i R ( R R R (
R! R R t curR R R R R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
1 c C@ s t | j | | S( N( R R ( R! R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR7 s c C@ s
t | S( s/ Extract just the content lines from a fulltext.( R ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c c@ sh t | } | j } xL | D]D } | j d } t | d } x t | D] } | VqN Wq Wd S( s Extract just the content from a line delta.
This doesn't return all of the extra information stored in a delta.
Only the actual content lines.
R i N( R RG R R R ( R! R RG R R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c C@ s
| j S( N( R, ( R! R1 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ sN g } xA | D]9 \ } } } } | j d | | | f | j | q
W| S( Ns %d,%d,%d
( R R ( R! R: R R R R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR9 s
c C@ s t | } | j | S( N( t _KnitAnnotatort
annotate_flat( R! R_ R> t annotator( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s ( R$ R% R& R R^ R R* R R7 R R R R9 R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c @ s f d } | S( s Create a factory for creating a file based KnitVersionedFiles.
This is only functional enough to run interface tests, it doesn't try to
provide a full pack environment.
:param annotated: knit annotations are wanted.
:param mapper: The mapper from keys to paths.
c @ sC t | d d d } t | } t | | d S( Nc S@ s d S( N( R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt <lambda> s c S@ s t S( N( R8 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s R^ ( t
_KndxIndext _KnitKeyAccessR ( t transportt indext access( R^ t mapper( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR- s !( ( R^ R R- ( ( R^ R s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt make_file_factory s c @ s f d } | S( s. Create a factory for creating a pack based VersionedFiles.
This is only functional enough to run interface tests, it doesn't try to
provide a full pack environment.
:param graph: Store a graph.
:param delta: Delta compress contents.
:param keylength: How long should keys be.
c
@ s p } d } r% | d 7} n r> | d 7} d } n d } t j d | d } | j d } t j | j } | j t | d d | d d
| j } t j
i } | j | | | d f t | | d | } | | _
| | _ | S( Ni i i t reference_listst key_elementst newpackc S@ s t S( N( R8 ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR % s RE t deltast add_callbackt max_delta_chain( t
_mod_indext InMemoryGraphIndext open_write_streamt packt ContainerWritert writet begint _KnitGraphIndext add_nodest pack_repot _DirectPackAccesst
set_writerR t streamt writer(
R RE t
ref_lengthR t graph_indexR R R R R ( R: t grapht keylength( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR- s,
( ( R R: R R- ( ( R: R R s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt make_pack_factory s
c C@ s | j j | j j d S( N( R t closeR R ( t versioned_files( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt cleanup_pack_knit1 s
c
C@ s i } | } xu | r t } xY | D]Q } | | k r= q% n | | \ } } } | | | <| | k r% | j | q% q% W| } q Wt g | j D] } | d ^ q S( s Determine the total bytes to build these keys.
(helper function because _KnitGraphIndex and _KndxIndex work the same, but
don't inherit from a common base.)
:param keys: Keys that we want to build
:param positions: dict of {key, (info, index_memo, comp_parent)} (such
as returned by _get_components_positions)
:return: Number of bytes to build those keys
i ( t sett addt sumt
itervalues(
R! t keyst positionst all_build_index_memost
build_keyst next_keysR> RV t
index_memoRN ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _get_total_build_size6 s
R c B@ s e Z d Z d e d, d Z d Z d Z d Z d, d, d, e e d Z
d, e d Z d Z d Z
d
Z d, d, d Z d Z d
Z d Z d Z d Z d Z e d Z i d Z d Z d Z e d Z d Z e d Z e d Z e d Z d Z! d Z" d Z# d Z$ d Z% d, d Z& d! Z' i d, d, d, d" Z( d# Z) d$ Z* d% Z+ d& Z, d' Z- d( Z. d, d) Z/ d* Z0 d+ Z1 RS(- s Storage for many versioned files using knit compression.
Backend storage is managed by indices and data objects.
:ivar _index: A _KnitGraphIndex or similar that can describe the
parents, graph, compression and data location of entries in this
KnitVersionedFiles. Note that this is only the index for
*this* vfs; if there are fallbacks they must be queried separately.
i c C@ sR | | _ | | _ | | _ | r0 t | _ n t | _ g | _ | | _ d S( s Create a KnitVersionedFiles with index and data_access.
:param index: The index for the knit data.
:param data_access: The access object to store and retrieve knit
records.
:param max_delta_chain: The maximum number of deltas to permit during
insertion. Set to 0 to prohibit the use of deltas.
:param annotated: Set to True to cause annotations to be calculated and
stored during insertion.
:param reload_func: An function that can be called if we think we need
to reload the pack listing and try again. See
'bzrlib.repofmt.pack_repo.AggregateIndex' for the signature.
N( t _indext _accesst _max_delta_chainR t _factoryR t _immediate_fallback_vfst _reload_func( R! R t data_accessR R^ t reload_func( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# ^ s c C@ s d | j j | j | j f S( Ns
%s(%r, %r)( t __class__R$ R R
( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt __repr__w s c C@ s( t | j | j | j | j j | j S( s? Return a clone of this object without any fallbacks configured.( R R R
R R R^ R ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt without_fallbacks} s c C@ s | j j | d S( s~ Add a source of texts for texts not present in this knit.
:param a_versioned_files: A VersionedFiles object.
N( R R ( R! t a_versioned_files( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt add_fallback_versioned_files s c
C@ sl | j j | j | | | | | d k r8 d } n d j | } | j | | | | | | | d | S( s See VersionedFiles.add_lines().R< t
line_bytesN( ( R t _check_write_okt
_check_addR R@ t _add(
R! R> RE R t parent_textst left_matching_blockst nostore_shat random_idt
check_contentR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt add_lines s
c
C@ s | j j | j | d | d t | j t k rG t j d n | d k r\ d } n | j | d | d d | | d | S( s See VersionedFiles._add_text().R! R, R N( (
R R R R R R t strR t BzrBadParameterUnicodeR ( R! R> RE R, R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _add_text s
c C@ s t | } | | k r$ t j n g }
| d
k r? i } n | j j | } x* | D]" } | | k rX |
j | qX qX Wt |
d k s |
d | d k r t }
n | j |
d }
t | } g } t } | r;| d d k r;| j d t
} | d
k r t j | } n | } | d d | d <n | d
k rYt j | } n x: | d D]. } t
| t k rdt d | f qdqdW| d d
k r| d d | f } n, t
| d t k rt d | f n | d } | j j | | } | rt
| _ n |
s?| j j rft |
d k rf| j | |
| |
| j j | } n |
r| j d | j j | } | j | | | \ } } n | j d | j j t k r| g } | r| j d n | j | | | | \ } } n- | j j | } | j | | | \ } } | j j | | f g | d } | j j | | | | f f d | | | | f S( s Add a set of lines on top of version specified by parents.
Any versions not present will be converted into ghosts.
:param lines: A list of strings where each one is a single line (has a
single newline at the end of the string) This is now optional
(callers can pass None). It is left in its location for backwards
compatibility. It should ''.join(lines) must == line_bytes
:param line_bytes: A single string containing the content
We pass both lines and line_bytes because different routes bring the
values to this function. And for memory efficiency, we don't want to
have to split/join on-demand.
i is
s no-eols key contains non-strings: %rs sha1:s
line-deltaRk R N( R R t ExistingContentR R t get_parent_mapR R R t _check_should_deltaR8 R R R R# t TypeErrorR R RM R^ t _merge_annotationsR9 R+ R R R R
t add_raw_recordst add_records( R! R> R RE R R R R R t digestt present_parentst present_parent_mapt parentR: t text_lengtht optionst no_eolt elementR R1 t delta_hunkst store_linesR2 R3 t dense_linest access_memo( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR sz
$
" c C@ s | j j | | S( s See VersionedFiles.annotate.( R R ( R! R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s
t | S( N( R ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt
get_annotator s c C@ s- | d k r | j S| j | d t Sd S( s See VersionedFiles.check().RB N( R t _logical_checkRF R8 ( R! t progress_barR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt check s
c C@ s | j j } | j | } xb | D]Z } | j j | d k r% | | d } | | k r t j | d | | f q q% q% Wx | j D] } | j q Wd S( NRk i s Missing basis parent %s for %s( R R R' t
get_methodR R R R< ( R! R t
parent_mapR> RN t fallback_vfs( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR: ' s
c C@ sk | d } | d k rD t | r4 t | | n | j | n | rg | j | | j | n d S( s0 check that version_id and lines are safe to add.iN( R R
R t check_not_reserved_idt _check_lines_not_unicodet _check_lines_are_lines( R! R> R R R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR 8 s
c C@ s' | j | } | j | | d | S( Ni( t
_split_headert _check_header_version( R! R> R R/ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt
_check_headerG s c C@ s4 | d | k r0 t | d | | d f n d S( s Checks the header version on original format knit records.
These have the last component of the key embedded in the record.
i s% unexpected version, wanted %r, got %rN( R ( R! R/ R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRD L s c C@ s d } d } x t | j D] } y# | j j | g } | | } Wn t t f k
ra } t SX| \ } } }
}
| \ }
}
} | d k r | } Pn | | 7} | } q Wt S| | k S( s Iterate back through the parent listing, looking for a fulltext.
This is used when we want to decide whether to add a delta or a new
fulltext. It searches for _max_delta_chain parents. When it finds a
fulltext parent, it sees if the total size of the deltas leading up to
it is large enough to indicate that we want a new full text anyway.
Return True if we should create a new delta, False if we should use a
full text.
i N( R R R R t get_build_detailsR t KeyErrorR ( R! R0 t
delta_sizet
fulltext_sizeR R\ t parent_detailsR R
RN RV R2 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR( U s"
c C@ s | d | d | d f S( s2 Convert a build_details tuple to a position tuple.i i i ( ( R! R\ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _build_details_to_components} s c C@ s i } | } x | r | j j | } t | } t } xe | j D]W \ } } | \ } }
} } | d }
|
d k r | j |
n | j | | | <qI W| j | } | r | r t j | j
| q q W| S( s Produce a map of position data for the components of keys.
This data is intended to be used for retrieving the knit records.
A dict of key to (record_details, index_memo, next, parents) is
returned.
* method is the way referenced data should be applied.
* index_memo is the handle to pass to the data access to actually get
the data
* next is the build-parent of the version, or None for fulltexts.
* parents is the version_ids of the parents of this version
:param allow_missing: If True do not raise an error on a missing
component, just ignore it.
i N( R RF R t iteritemsR R RK t
differenceR R t pop( R! R t
allow_missingt component_datat pending_componentsR\ t current_componentsR> t detailsR
RN RE R R t missing( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _get_components_positions s
c C@ se | j | d } | d k rF | j | g sB t | | n | St | | g } | j | S( sE Returns a content object that makes up the specified
version.N( Rl R R' R t _VFContentMapGeneratorR ( R! R> R t cached_versionRv ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s | j | d S( s Get a map of the graph parents of keys.
:param keys: The keys to look up parents for.
:return: A mapping from keys to parents. Absent keys are absent from
the mapping.
i ( t _get_parent_map_with_sources( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR' s c C@ s i } | j g | j } g } t | } xT | D]L } | sB Pn | j | } | j | | j | | j t | q2 W| | f S( s Get a map of the parents of keys.
:param keys: The keys to look up parents for.
:return: A tuple. The first element is a mapping from keys to parents.
Absent keys are absent from the mapping. The second element is a
list with the locations each key was found in. The first element
is the in-this-knit parents, the second the first fallback source,
and so on.
( R R R R' R t updatet difference_update( R! R R t sourcest source_resultsRT R t
new_result( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRX s
c C@ s" | j | d | } | j | S( s Produce a dictionary of knit records.
:return: {key:(record, record_details, digest, next)}
* record: data returned from read_records (a KnitContentobject)
* record_details: opaque information to pass to parse_record
* digest: SHA1 digest of the full text after all steps are done
* next: build-parent of the version, i.e. the leftmost ancestor.
Will be None if the record is not a delta.
:param keys: The keys to build a map for
:param allow_missing: If some records are missing, rather than
error, just return the data that could be generated.
RO ( t _get_record_map_unparsedt _raw_map_to_record_map( R! R RO t raw_map( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _get_record_map s c C@ s` i } xS | D]K } | | \ } } } | j | d | \ } } | | | | f | | <q
W| S( s_ Parse the contents of _get_record_map_unparsed.
:return: see _get_record_map.
i( t
_parse_record( R! R` R R> t dataR RG R1 R- ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR_ s
c C@ s x t r y | j | d | } g | j D]! \ } \ } } } | | f ^ q. } | j d t j d i } xC | j | D]2 \ } }
| | \ } } }
|
| |
f | | <q W| SWq t j k
r } | j j
| q Xq Wd S( s Get the raw data for reconstructing keys without parsing it.
:return: A dict suitable for parsing via _raw_map_to_record_map.
key-> raw_bytes, (method, noeol), compression_parent
RO R> i N( R8 RU RL t sortt operatort
itemgettert _read_records_iter_uncheckedR t RetryWithNewPacksR
t reload_or_raise( R! R RO t position_mapR> t rt i_mR t recordst raw_record_mapRc R R
RG R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR^ s
1 c C@ s i } g } xm | D]e } t | d k r4 d } n
| d } | | k r^ | | j | q | g | | <| j | q W| | f S( s For the given keys, split them up based on their prefix.
To keep memory pressure somewhat under control, split the
requests back into per-file-id requests, otherwise "bzr co"
extracts the full tree into memory before writing it to disk.
This should be revisited if _get_content_maps() can ever cross
file-id boundaries.
The keys for a given file_id are kept in the same relative order.
Ordering between file_ids is not, though prefix_order will return the
order that the key was first seen.
:param keys: An iterable of key tuples
:return: (split_map, prefix_order)
split_map A dictionary mapping prefix => keys
prefix_order The order that we saw the various prefixes
i R< i ( R R ( t clsR t split_by_prefixt prefix_orderR> R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _split_by_prefix s
c C@ s. t | } | j | \ } } | j | \ } } g }
t } d } g }
g } x | D] } | | } | j | g } | j j | | } | | 7} |
j | | j | | | k r^ |
j |
| f | j | g }
t } d } q^ q^ W|
r*|
j |
| f | j | n |
S( s For the given keys, group them into 'best-sized' requests.
The idea is to avoid making 1 request per file, but to never try to
unpack an entire 1.5GB source tree in a single pass. Also when
possible, we should try to group requests to the same pack file
together.
:return: list of (keys, non_local) tuples that indicate what keys
should be fetched next.
i ( R Rr R Rl R R R RY R ( R! R t non_local_keysR t _min_buffer_sizet
total_keyst prefix_split_keysRq t prefix_split_non_local_keysRV t cur_keyst
cur_non_localt cur_sizeR t sizesR t non_localt this_size( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _group_keys_for_io2 s2
c c@ s t | } | s d S| j j s+ d } n | } x| t r yI t | } x2 | j | | | D] } | j | j | Vq_ Wd SWq4 t j k
r } | j j
| q4 Xq4 Wd S( s Get a stream of records for keys.
:param keys: The keys to include.
:param ordering: Either 'unordered' or 'topological'. A topologically
sorted stream has compression parents strictly before their
children.
:param include_delta_closure: If True then the closure across any
compression parents will be included (in the opaque data).
:return: An iterator of ContentFactory objects, each of which is only
valid until the iterator is advanced.
NRB ( R R t has_graphR8 t _get_remaining_record_streamt discardR> R Rh R
Ri ( R! R t orderingt include_delta_closuret remaining_keyst content_factoryR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRF ] s
c
#@ s | r j | d t } n4 j j | } t f d | j D } | j t | } | rt } i } x
| D] } y | | | d g }
Wn! t k
r | j | q n Xt } x |
d d k rL|
d | k r | |
d } Pq y |
j | |
d d Wq t k
rH| j |
d t } Pq Xq Wx |
d D] } | | | <qXW| s | j | q q Wn j | \ }
} | d
k rX| d k rt
j |
} n t |
} g } d } x=| D]j } x$ | D] } | | k r| } PqqW| | k r<| j | g f | } n | d d j | qWn | d k rzt d | f n g } g } xZ t | D]L } | j | g f x0 | D]( } | j | | d d j | qWqWx: | D]2 \ } } | | d
k r j j | | qqW| t |
} x | D] } t | Vq7W| r| | } xG j | | | D]C \ } } t | | |
d | } x | j D] } | VqWqrWn x | D] \ } } | | d
k rcg | D] } | | | d f ^ q} x j | D]F \ } } | | \ } } } t | |
| | d | j j d VqWq j | j | d } x" | j | | | D] } | VqWqWd S( s; This function is the 'retry' portion for get_record_stream.RO c 3@ s* | ] \ } } | j | f Vq d S( N( RK ( Rd R> RS ( R! ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr> s i it topologicalt
groupcompressi RB sT valid values for ordering are: "unordered", "groupcompress" or "topological" not: %ri R N( R R ( RU R8 R RF t dictRL RM R RG R R R RX t tsortt topo_sortR t AssertionErrort reversedt _sort_keys_by_ioR R~ RV RF Rg RW R R^ R R ( R! R R R R R\ t absent_keyst needed_from_fallbackt reconstructable_keysR> t chainR t chain_keyt
global_mapt parent_mapst present_keyst source_keyst current_sourceR> t
key_sourceR t sub_keysRs Rv R Rm t raw_dataR R
RV t vf( ( R! s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR } s
'
!
c C@ s t | } | j | d t } i } x: | j D], \ } } | | k rR q4 n | d | | <q4 W| j t | xJ | j D]? } | s Pn | j | } | j | | j t | q W| S( s See VersionedFiles.get_sha1s().RO i ( R Ra R8 RL RZ R t get_sha1sRY ( R! R RT t
record_mapR R> RS R R] ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c @ s f d } t } j j r6 d } g } n; d } t d g } j rq | j d | j d n t } j r | j d | | j d | n | j d | | j | } i i } x| D]} | j }
|
j d r9|
j d r9| j } j
| j | \ } }
| j n t
} | j } | j | k rd| d
} n d } | j d k rt | j g nl| j | k r%| d k s j s j j | s j | r%| j | k rGy | j d f } | | } Wn, t k
r4| j d
f } | | } n X| j | } n | j } | j d
g } | j d r}| j d n j j | j t | f g | d
} | j | | | f } d | k r j j | s| j | g } | j | t } qn | s j j | g qn | j d k r_ j | j | t j | j! d n j j" y | j! d } Wn> t# j$ k
r| j d f } | | } | j | } n Xt% | } y j | j | | Wn t# j& k
rn X| s | j g } xp | r~| j' d
} | | k r| | } j j | | j( g | D] } | d
^ qZ | | =qqWq q W| rg } x% | D] } | | } | j( | qW j j | d t n d S( s Insert a record stream into this container.
:param stream: A stream of records to insert.
:return: None
:seealso VersionedFiles.get_record_stream:
c @ sJ y | SWn7 t k
rE t j | } | } | | <| SXd S( N( RG R Rl ( Rp Rq Rr ( t adaptersR! ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_adapter s
s
annotated-R< s knit-annotated-ft-gzs knit-annotated-delta-gzs knit-%sdelta-gzs knit-%sft-gzs knit-s -gzi RC s
knit-delta-gzs
knit-ft-gzi s no-eolRk RD t missing_compression_parentsN() R R R^ R R t unionRH t
startswitht endswithR( t _parse_record_headerR> R R RE R R R R t has_keyRG R4 R? R R
R+ R R R8 R, R" R RJ RI t flushR Ro R t RevisionAlreadyPresentRN R ( R! R R t delta_typesR^ t convertiblest native_typest
knit_typest buffered_index_entriesR Ra R t dfR/ t bufferedRE RN Rp Rr R3 R2 R8 t index_entryt pendingR t
added_keysR> t
index_entriest all_entries( ( R R! s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt insert_record_stream s
"
c C@ s
| j j S( s Return an iterable of keys of missing compression parents.
Check this after calling insert_record_stream to find out if there are
any missing compression parents. If there are, the records that
depend on them are not able to be inserted safely. For atomic
KnitVersionedFiles built on packs, the transaction should be aborted or
suspended - commit will fail at this point. Nonatomic knits will error
earlier because they have no staging area to put pending entries into.
( R t get_missing_compression_parents( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt# get_missing_compression_parent_keys s
c c@ s@ | d k r t j j } n t | } t | } t } xP| sy g } | j j | } x@ | j D]2 \ } } | | k rm | j
| | d f qm qm Wt | j | } x | D] \ }
\ } } } | j
t d |
| | | d }
|
d k r | j j | } n | j j | } | j | x | D] } | | f VqBWq Wt } Wq? t j k
r} | j j | q? Xq? W| r| j rt | t | n xi | j D]^ } | sPn t } x5 | j | D]$ \ } } | j | | | f VqW| j | qW| j
t d | | d S( s Iterate over the lines in the versioned files from keys.
This may return lines from other keys. Each item the returned
iterator yields is a tuple of a line and a text version that that line
is present in (not introduced in).
Ordering of results is in whatever order is most suitable for the
underlying storage format.
If a progress bar is supplied, it may be used to indicate progress.
The caller is responsible for cleaning up progress bars (because this
is an iterator).
NOTES:
* Lines are normalised by the underlying store: they will all have \n
terminators.
* Lines are returned in arbitrary order.
* If a requested key did not change any lines (or didn't have any
lines), it may not be mentioned at all in the result.
:param pb: Progress bar supplied by caller.
:return: An iterator over (line, key).
i s Walking contenti N( R t uit
ui_factoryt nested_progress_barR R R R RF RL R t enumeratet _read_records_iterRY t gettextR R R t removeR8 R Rh R
Ri R R t reprt# iter_lines_added_or_present_in_keysR RZ ( R! R t pbt totalt donet key_recordsR\ R> RS t records_itert key_idxRc t sha_valueRN t
line_iteratorR R R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR sH
c C@ sv g } xi | j D][ } | d d k r/ q n | j | d | d | d | d | j | d | d !f q W| S( s5 Generate a line delta from delta_seq and new_content.i R i i i i ( R R R ( R! t delta_seqt new_contentt
diff_hunkst op( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _make_line_delta s Cc C@ s | d k r t j | } n d } | rDx | D] } | j | | } | | d k rn | d k rn | }
n! t j d | j | j }
xQ |
j D]C \ } } }
|
d k r q n | j | | |
!| j | | |
+q Wq1 W| j rD| j d d d d k rD| j d d d } | j d d | f | j d <qDn | r| d k r| j | d | } | j } | j } t j d | | } n | j | | Sd S( s Merge annotations for content and generate deltas.
This is done by comparing the annotations based on changes to the text
and generating a delta on the resulting full texts. If annotations are
not being created then a simple delta is created.
i ii s
N(
R t difft _PrematchedMatcherR R R R, t get_matching_blocksR R ( R! R1 RE R R: R^ R R t
parent_keyt
merge_contentt seqR t jR R t reference_contentR R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR* s2
*$$ c C@ s3 | j | \ } } | j | | | | d f S( s Parse an original format knit record.
These have the last element of the key only present in the stored data.
i ( R) RD ( R! R Rc R/ t record_contents( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRb B s c C@ s t j d d d t | } y | j | | j } Wn; t k
rw } t | d | | j j t | f n X| | f S( s Parse a record header for consistency.
:return: the header and the decompressor stream.
as (stream, header_record)
t modet rbt fileobjs While reading {%s} got %s(%s)(
t gzipt GzipFileR RE t readlinet ExceptionR R R$ R# ( R! R> R R R/ R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR K s #c C@ s0 t j d d d t | } y | j } Wn; t k
rk } t | d | | j j t | f n X| j d } | j
| } | j } t | t | d k r t | d t | t | d | d | f n | d | d k r t | d
| | d f n | j
| | f S( NR R R s( Corrupt compressed record %r, got %s(%s)i i s6 incorrect number of lines %s != %s for version {%s} %si s end %s
s) unexpected version end line %r, wanted %r( R R R t readlinesR R R R$ R# RN RC R R R ( R! Rc R R R R R/ R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR) [ s( #
c c@ s | s
d St t | d t j d } | s5 d S| j j g | D] \ } } | ^ qE } xS t t | | D]< \ \ } } } | j | d | \ } } | | | f Vqv Wd S( s Read text records from data file and yield result.
The result will be returned in whatever is the fastest to read.
Not by the order requested. Also, multiple requests for the same
record will only yield 1 response.
:param records: A list of (key, access_memo) entries
:return: Yields (key, contents, digest) in the order
read, not the order requested
NR> i i( t sortedR Re Rf R
t get_raw_recordsR R Rb ( R! Rm t needed_recordsR> R
R Rc R1 R- ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR v s ! "% c c@ sX xQ | j | D]@ \ } } | j | | \ } } | j | | | d f Vq Wd S( s Read text records from data file and yield raw data.
This unpacks enough of the text record to validate the id is
as expected but thats all.
Each item the iterator yields is (key, bytes,
expected_sha1_of_full_text).
i N( Rg R R ( R! Rm R> Rc R R/ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _read_records_iter_raw s
c c@ sr t | r@ g | D] \ } } | ^ q } | j j | } n x+ | D]# \ } } | j } | | f VqG Wd S( s Read text records from data file and yield raw data.
No validation is done.
Yields tuples of (key, data).
N( R R
R RG ( R! Rm R> R
t needed_offsetst raw_recordsRc ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRg s c C@ s d | d t | | f g } | j | p/ | | j d | d x9 | D]1 } t | t k rO t d t | qO qO W| r | d d d k r t d | n t j | } t | | f S( s Convert key, digest, lines into a raw data block.
:param key: The key of the record. Currently keys are always serialised
using just the trailing component.
:param dense_lines: The bytes of lines but in a denser form. For
instance, if lines is a list of 1000 bytestrings each ending in
\n, dense_lines may be a list with one line in it, containing all
the 1000's lines and their \n's. Using dense_lines if it is
already known is a win because the string join to create bytes in
this function spends less time resizing the final string.
:return: (len, a StringIO instance with the raw data ready to read.)
s version %s %d %s
is end %s
s data must be plain bytes was %ss
s corrupt lines value %r( R R R R R# R R t
tuned_gzipt chunks_to_gzip( R! R> R- R R7 Rz t chunkRT ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR+ s
c C@ s4 | j } t | d k r0 t | d n | S( Ni s. unexpected number of elements in record header( R R R ( R! R R/ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRC s
c C@ sf d t j k r" t j d d n | j g | j } t } x! | D] } | j | j qE W| S( s See VersionedFiles.keys.t evili s keys scales with size of history( t debugt debug_flagst tracet mutter_callsiteR R R RY R ( R! R[ R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
N(2 R$ R% R& R R R# R R R R8 R" R% R R R9 R< R: R RE RD R( RK RU R R' RX Ra R_ R^ t classmethodRr t _STREAM_MIN_BUFFER_SIZER~ RF R R R R R R R* Rb R R) R R Rg R+ RC R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR S s` o ( # # * w O + t _ContentMapGeneratorc B@ sG e Z d Z d d Z d Z d Z d Z d Z d Z RS( s7 Generate texts or expose raw deltas for a set of texts.RB c C@ s
| | _ d S( N( t _ordering( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s c C@ sZ | | j k rI | j j } t j | j d } t | | j S| j | Sd S( s Get the content object for key.RD N( t
nonlocal_keysRF RG R RJ RI RK R> Ry ( R! R> R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c c@ s x | j D] } | Vq
Wd S( s; Get a record stream for the keys requested during __init__.N( t _work( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRF s c c@ s | j d k r* | j j | j | _ n | j } t | } xk | j j D]] } | s\ Pn xJ | j | | j t
D]0 } | j d k r qu n | j | j
| Vqu WqL W| j d k r t d n t
} xG | j D]< } | | j k r q n t | | j | | | Vt } q Wd S( s Produce maps of text and KnitContents as dicts.
:return: (text_map, content_map) where text_map contains the texts for
the requested versions and content_map contains the KnitContents.
RC s' _raw_record_map should have been filledN( R R R R' R R R R RF R R8 RH R R> t _raw_record_mapR Rs R ( R! R t missing_keysR R Rw R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s*
c C@ s | | j k r | j | St | j d k } | j d k rY | j j | j | _ n | j } x| j D]} | | j k r ql n g } | } x | d k r-y | | \ } } } }
Wn t k
r t
| | n X| j | | | | f |
} | | j k r | j | d d d f Pq q Wd } x t | D]r \ } } } } | | j k rr| j | } qA| j
j | d | | | d | \ } }
| rA| | j | <qAqAW| j } t | } | | k rl t | | | | | ql ql W| r | j | S| Sd S( Ni iR ( t
_contents_mapR R t _record_mapR R R_ R R RG R R R R R= R, R R ( R! t
requested_keyt multiple_versionsR R> t
componentst cursorR R R- RG R1 t component_idR: R, t
actual_sha( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRy sN
c
C@ s g } | j d | j j j r2 | j d n
| j d | j d j g | j D]$ } | | j k rU d j | ^ qU g } x | j j D] \ } \ } \ } } } d j | } | j j
| d } | d k r d }
n d j d | D }
| } | rd } n d } | r9d j | }
n d }
| j d
| |
| | |
t | | f q Wd j | } | j | d j | } | S(
s Get the bytes to put on the wire for 'key'.
The first collection of bytes asked for returns the serialised
raw_record_map and the additional details (key, parent) for key.
Subsequent calls return just the additional details (key, parent).
The wire storage_kind given for the first key is 'knit-delta-closure',
For subsequent keys it is 'knit-delta-closure-ref'.
:param key: A key from the content generator.
:return: Bytes to put on the wire.
s knit-delta-closureR^ R< s Rc s None:c s@ s | ] } d j | Vq d S( Rc N( R@ ( Rd R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr> s t Tt Fs %s
%s
%s
%s
%s
%d
%ss
N(
R R R R^ R@ R R R RL R Rl R R ( R! R R> t
map_byte_listt record_bytesR Ri RG Rg RE Rh t method_bytest noeol_bytest
next_bytest map_bytesR3 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRx Y s:
( (
( R$ R% R& R# R RF R Ry Rx ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
& :RV c B@ s# e Z d Z d d d d d Z RS( s; Content map generator reading from a VersionedFiles object.RB c C@ s t j | d | | | _ t | | _ | d k rF t | _ n t | | _ | | _ i | _
i | _ d | _ | d k r | j j
| d t | _ n | | _ | j j | _ d S( sy Create a _ContentMapGenerator.
:param versioned_files: The versioned files that the texts are being
extracted from.
:param keys: The keys to produce content maps for.
:param nonlocal_keys: An iterable of keys(possibly intersecting keys)
which are known to not be in this knit, but rather in one of the
fallback knits.
:param global_map: The result of get_parent_map(keys) (or a supermap).
This is required if get_record_stream() is to be used.
:param raw_record_map: A unparsed raw record map to use for answering
contents.
R RO N( R R# R R R R R R t frozensetR t _text_mapR R R^ R8 R R ( R! R R R R Rn R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s N( R$ R% R& R R# ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRV s R{ c B@ s) e Z d Z d Z d Z d Z RS( s4 Content map generator sourced from a network stream.c C@ s | | _ i | _ i | _ i | _ d | _ g | _ t d d | _ | } | j d | } | | | !} | d } | d k r t
| _ n t | _ | j d | } | | | !} | d } g | j
d D]! } | r t | j
d ^ q | _ t | } x| | k r| j d | } t | | | !j
d } | d } | j d | } | | | !} | d k rd } n= t g | j
d D]! } | rt | j
d ^ q } | | j | <| d } | j d | } | | | !} | } | d } | j d | } | | | !} | d k }
| d } | j d | } | | | !} | snd } n t | | | !j
d } | d } | j d | } | | | !} t | } | d } | | | | !}
| | } |
| |
f | f | j | <qWd S( s; Construct a _NetworkContentMapGenerator from a bytes block.s
i R^ s Rc s None:R N( t _bytesR R R R R R R R R~ R R R R R R R R ( R! R3 R| R R R R R> RE R Ri RG R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# sl
$
$
c c@ s? t } x2 | j D]' } t | | j | | | Vt } q Wd S( s= Get a record stream for for keys requested by the bytestream.N( R8 R Rs R R ( R! Rw R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRF s c C@ s | j S( N( R ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRx s ( R$ R% R& R# RF Rx ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR{ s K R c B@ s e Z d Z d Z d Z e e d Z d Z d Z d Z d Z
d Z d Z d
Z
d Z d Z d
Z d Z d Z e j Z g d Z d Z d Z e j Z d Z d Z d Z d Z e Z d Z RS( sF Manages knit index files
The index is kept in memory and read on startup, to enable
fast lookups of revision information. The cursor of the index
file is always pointing to the end, making it easy to append
entries.
_cache is a cache for fast mapping from version id to a Index
object.
_history is a cache for fast mapping from indexes to version ids.
The index data format is dictionary compressed when it comes to
parent references; a index entry may only have parents that with a
lover index number. As a result, the index is topological sorted.
Duplicate entries may be written to the index for a single version id
if this is done then the latter one completely replaces the former:
this allows updates to correct version and parent information.
Note that the two entries may share the delta, and that successive
annotations and references MUST point to the first entry.
The index file on disc contains a header, followed by one line per knit
record. The same revision can be present in an index file more than once.
The first occurrence gets assigned a sequence number starting from 0.
The format of a single line is
REVISION_ID FLAGS BYTE_OFFSET LENGTH( PARENT_ID|PARENT_SEQUENCE_ID)* :
REVISION_ID is a utf8-encoded revision id
FLAGS is a comma separated list of flags about the record. Values include
no-eol, line-delta, fulltext.
BYTE_OFFSET is the ascii representation of the byte offset in the data file
that the compressed data starts at.
LENGTH is the ascii representation of the length of the data file.
PARENT_ID a utf-8 revision id prefixed by a '.' that is a parent of
REVISION_ID.
PARENT_SEQUENCE_ID the ascii representation of the sequence number of a
revision id already in the knit that is a parent of REVISION_ID.
The ' :' marker is the end of record marker.
partial writes:
when a write is interrupted to the index file, it will result in a line
that does not end in ' :'. If the ' :' is not present at the end of a line,
or at the end of the file, then the record that is missing it will be
ignored by the parser.
When writing new records to the index file, the data is preceded by '
'
to ensure that records always start on new lines even if the last write was
interrupted. As a result its normal for the last line in the index to be
missing a trailing newline. One can be added with no harmful effects.
:ivar _kndx_cache: dict from prefix to the old state of KnitIndex objects,
where prefix is e.g. the (fileid,) for .texts instances or () for
constant-mapped things like .revisions, and the old state is
tuple(history_vector, cache_dict). This is used to prevent having an
ABI change with the C extension that reads .kndx files.
s # bzr knit index 8
c C@ sD | | _ | | _ | | _ | | _ | | _ | j t | _ d S( s. Create a _KndxIndex on transport using mapper.N( t
_transportt _mappert
_get_scopet
_allow_writest
_is_lockedt _reset_cacheR8 R ( R! R R t get_scopet allow_writest is_locked( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# X s
c C@ s | r1 t d | D } t j | | n i } xa | D]Y } | d } | d } | j j | d } | j | | g f }
|
d j | q> Wx}t | D]o} | | \ } }
| j | g g } | j | d } | j | d j }
y x |
D] \ } } \ } } } } | d
k r7d } n d | d d j | | | | j | f } t
| t k rt d t
| n | j | | j | | | | | qWt | r| j j | d j | n | j | | Wq |
| f | j | < q Xq Wd
S( s? Add multiple records to the index.
:param records: a list of tuples:
(key, options, access_memo, parents).
:param random_id: If True the ids being added were randomly generated
and no check for existence will be performed.
:param missing_compression_parents: If True the records being added are
only compressed against texts already in the index (or inside
records). If False the records all refer to unavailable texts (or
texts inside records) as compression parents.
c s@ s | ] } | d Vq d S( i N( ( Rd R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr>q s i is .kndxi s
%s %s %s %s %s :R s data must be utf8 was %sR< N( ( R R R R t mapR R t _load_prefixest _kndx_cacheR R R@ t _dictionary_compressR R# R t
_cache_keyR R t append_bytest _init_index( R! Rm R R R t pathsR R> R t patht path_keysR t orig_historyt
orig_cacheR2 RV t posR2 RE R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR, b sD
"
c C@ s t | j d S( s+ See _KnitGraphIndex.scan_unvalidated_index.N( R t scan_unvalidated_index( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s t | j d S( s4 See _KnitGraphIndex.get_missing_compression_parents.N( R R ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c
C@ s | d } | d } t d | D } x7 | D]/ } | d | k r1 t d | | f q1 q1 W| j | \ }
} | |
k r t | } | j | n |
| d } | | | | | | f |
| <d S( s Cache a version record in the history array and index cache.
This is inlined into _load_data for performance. KEEP IN SYNC.
(It saves 60ms, 25% of the __init__ overhead on local 4000 record
indexes).
ic s@ s | ] } | d Vq d S( iN( ( Rd R0 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr> s s mismatched prefixes for %r, %ri N( R R R R R (
R! R> R2 R R2 t parent_keysR R RE R0 R t historyR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s$
c C@ sU | j } | d k r* t j | n | | j k rQ t d | d | n d S( NR< t badlinet filename( R R R t HEADERR
( R! t fpR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt check_header s
c C@ sD | j s t j | n | j | j k r@ | j n d S( N( R R t ObjectNotLockedR t _scopeR ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _check_read s c C@ se | j s t j | n | j | j k r@ | j n | j d k ra t j | n d S( s# Assert if not writes are permitted.t wN( R R R% R R& R t _modet ReadOnlyObjectDirtiedError( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c
C@ s | j | } i } x | D] } | | k r4 q n | j | } | | } | d k rb d } n
| d } d | j | k } | j | } | | | | | f f | | <q W| S( s Get the method, index_memo and compression parent for keys.
Ghosts are omitted from the result.
:param keys: An iterable of keys.
:return: A dict of key:(index_memo, compression_parent, parents,
record_details).
index_memo
opaque structure to pass to read_records to extract the raw
data
compression_parent
Content that this record is built upon, may be None
parents
Logical parents of this node
record_details
extra information about the content which needs to be passed to
Factory.parse_record
Rk i s no-eolN( R' R= R t get_optionst get_position(
R! R R> R R> R RE RN Ri R
( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRF s
c C@ sE | j | } d | k r d Sd | k r/ d St j | | d S( s+ Return compression method of specified key.Rk s
line-deltaN( R+ R t KnitIndexUnknownMethod( R! R> R2 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR= s c C@ sg | j | \ } } | j | g y | j | d | d SWn t k
rb t | | n Xd S( sI Return a list representing options.
e.g. ['foo', 'bar']
i i N( t
_split_keyR R RG R ( R! R> R t suffix( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR+
s
c
C@ s! t d | D } | j | i } i } t } t | } x | r| j } | | k rk qG n | d } y! | j | d | d d } Wn t k
r | j | qG Xt g | D] }
| |
f ^ q } | | | <| j g | D] } | | k r | ^ q qG W| | f S( s& See CombinedGraphIndex.find_ancestry()c s@ s | ] } | d Vq d S( iN( ( Rd R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr>
s ii i ( R R R RN R RG R R R (
R! R t prefixesR R> R t pending_keysR> R t suffix_parentsR/ R t p( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt
find_ancestry
s*
!
c @ s t d | D } | j | i } xm | D]e } | d y! | j d | d d } Wn t k
rt q0 Xt f d | D | | <q0 W| S( s Get a map of the parents of keys.
:param keys: The keys to look up parents for.
:return: A mapping from keys to parents. Absent keys are absent from
the mapping.
c s@ s | ] } | d Vq d S( iN( ( Rd R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr>8
s ii i c 3@ s | ] } | f Vq d S( N( ( Rd R/ ( R ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pys <genexpr>B
s ( R R R RG R ( R! R R0 R R> R2 ( ( R s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR' .
s
!
c C@ sO | j | \ } } | j | g | j | d | } | | d | d f S( s Return details needed to access the version.
:return: a tuple (key, data position, size) to hand to the access
logic to get the record.
i i i ( R. R R ( R! R> R R/ t entry( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR, F
s c C@ sP t } | j | j | j | | j d | j j | | d t d S( s Initialize an index.i t create_parent_dirN( R R R" t
writelinest seekR t put_file_non_atomicR8 ( R! R t extra_linest sio( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR S
s
c C@ s t } t | j t k r* d g } nm t } x< | j j D]+ } t j j | \ } } | j | qC Wg | D] } | j j
| ^ qy } | j | x> | D]6 } x- | j | d D] } | j | | f q Wq W| S( sO Get all the keys in the collection.
The keys are not ordered.
i ( (
R R R R R t iter_files_recursivet osR t splitextR t unmapR R ( R! R R0 t relpathst quoted_relpathR t extR R/ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR _
s %
c C@ s | j x| D]} | | j k r i | _ g | _ | | _ yv | j j | d } | j j | } z t | | Wd | j
X| j | j f | j | <| ` | ` | ` Wqt k
ri g f | j | <t | j t
k r | j | n | ` | ` | ` qXq q Wd S( s Load the indices for prefixes.s .kndxN( R' R t _cachet _historyt _filenameR R R Rl t
_load_dataR R R R R ( R! R0 R R R# ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR u
s.
c C@ sB i } x5 | D]- } | j | d g } | j | d q
W| S( s, Turn keys into a dict of prefix:suffix_list.i( R R ( R! R R R> t prefix_keys( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _partition_keys
s
c C@ s | s
d Sg } | d d } | j | d } xx | D]p } | d | k r_ t d | n | d | k r | j t | | d d q6 | j d | d q6 Wd j | S( s Dictionary compress keys.
:param keys: The keys to generate references to.
:return: A string representation of keys. keys which are present are
dictionary compressed, and others are emitted as fulltext with a
'.' prefix.
R< i is mismatched prefixes for %ri t .Rf ( R R R R# R@ ( R! R t result_listR R R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR
s
"c C@ sC i | _ | j | _ | j } | r6 d | _ n d | _ d S( NR( Rk ( R R R& R
R) ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR
s c @ s f d } | j d | S( su Figure out an optimal order to read the records for the given keys.
Sort keys, grouped by index and sorted by position.
:param keys: A list of keys whose records we want to read. This will be
sorted 'in-place'.
:param positions: A dict, such as the one returned by
_get_components_positions()
:return: None
c @ s$ | d } | d d | d f S( Ni i i( ( R> R
( R ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_sort_key
s R> ( Rd ( R! R R RK ( ( R s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR
s c C@ s | d | d f S( s# Split key into a prefix and suffix.i( ( R! R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR.
s (! R$ R% R& R" R# R R, R R R R$ R' R RF R= R+ R4 R' R, R t _has_key_from_parent_mapR R R R t _missing_keys_from_parent_mapR RH R R R R R. ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s6 9
5 $
R c B@ s e Z d Z e e d e d Z d Z e e d Z d Z d Z
d Z d Z d Z
d Z d
Z e d Z d Z d
Z d Z d Z d Z d Z d Z e j Z d Z e j Z d Z d Z e Z RS( s1 A KnitVersionedFiles index layered on GraphIndex.c C@ s | | _ | | _ | | _ | | _ | rC | rC t | d n | | _ | | _ t | _ | rv t | _
n d | _
d S( sn Construct a KnitGraphIndex on a graph_index.
:param graph_index: An implementation of bzrlib.index.GraphIndex.
:param is_locked: A callback to check whether the object should answer
queries.
:param deltas: Allow delta-compressed records.
:param parents: If True, record knits parents, if not do not record
parents.
:param add_callback: If not None, allow additions to the index and call
this callback with a list of added GraphIndex nodes:
[(node, value, node_refs), ...]
:param is_locked: A callback, returns True if the index is locked and
thus usable.
:param track_external_parent_refs: If True, record all external parent
references parents from added records. These can be retrieved
later by calling get_missing_parents().
s4 Cannot do delta compression without parent tracking.N( t
_add_callbackt _graph_indext _deltast _parentsR R R R t _missing_compression_parentsR t _key_dependenciesR ( R! R R R RE R t track_external_parent_refs( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR#
s
c C@ s d | j j | j f S( Ns %s(%r)( R R$ RO ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ s | j s t j | n i } t } | j } xP| D]H\ } } } }
| j r t |
}
| d k r | j | |
q n | \ } } }
d | k r d } n d } | d | |
f 7} | j s d | k r t
| d q n | j rT| j rHd | k r9|
|
d f f } | rE| j |
d qEqQ|
d f } qr|
f } n |
rlt
| d n d
} | | f | | <q: W| sF| j | } x | D] \ } } } } | d }
t
j | | } | d d } | d | | d d k s|
| k r8t
j | } t
| d
| | f | f n | | =qWn g } | j rxo | j D]( \ } \ } } | j | | | f qbWn6 x3 | j D]% \ } \ } } | j | | f qW| j | | r| j | | j j | n | j j | d S( sY Add multiple records to the index.
This function does not insert data into the Immutable GraphIndex
backing the KnitGraphIndex, instead it prepares data for insertion by
the caller and checks that it is safe to insert then calls
self._add_callback with the prepared GraphIndex nodes.
:param records: a list of tuples:
(key, options, access_memo, parents).
:param random_id: If True the ids being added were randomly generated
and no check for existence will be performed.
:param missing_compression_parents: If True the records being added are
only compressed against texts already in the index (or inside
records). If False the records all refer to unavailable texts (or
texts inside records) as compression parents.
s no-eolRe Rf s %d %ds
line-deltas+ attempt to add line-delta in non-delta kniti s5 attempt to add node with parents in parentless index.i s* inconsistent details in add_records: %s %sN( ( ( RN R t
ReadOnlyErrorR RS RQ R R t add_referencesRP R R t _get_entriest static_tuplet as_tuplesRL R RZ RR RY ( R! Rm R R R t compression_parentst key_dependenciesR> R2 R8 RE R R R2 t valuet node_refst
present_nodest passedt passed_parentsR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR, sj
c C@ s | j rD | j d d } | j | j | | j j | n | j d k r x6 | j D]% } | j j | d | d d q` Wn d S( s Inform this _KnitGraphIndex that there is an unvalidated index.
This allows this _KnitGraphIndex to keep track of any missing
compression parents we may want to have filled in to make those
indices valid.
:param graph_index: A GraphIndex
t ref_list_numi i i N(
RP t external_referencesRZ R' RR RY RS R t iter_all_entriesRV ( R! R t new_missingt node( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR a s c C@ s
t | j S( s Return the keys of missing compression parents.
Missing compression parents occur when a record stream was missing
basis texts, or a index was scanned that had missing basis texts.
( R RR ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR t s c C@ s5 | j j | j | j j t | j j S( s# Return the keys of missing parents.( RS t satisfy_refs_for_keysR' t get_unsatisfied_refsR ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_missing_parents| s c C@ s" | j s t j | n d S( s! raise if reads are not permitted.N( R R R% ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR' s c C@ s" | j s t j | n d S( s# Assert if writes are not permitted.N( R R R% ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s c C@ sE | d d } | s d St | d k r= t d | n | d S( Ni i s Too many compression parents: %ri ( R R R ( R! t an_entryRZ ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _compression_parent s c
C@ s | j i } | j | t } x | D] } | d } | j sK d } n | d d } | j sk d } n | j | } | d d d k } | r d } n d } | j | | | | | f f | | <q) W| S(
s Get the method, index_memo and compression parent for version_ids.
Ghosts are omitted from the result.
:param keys: An iterable of keys.
:return: A dict of key:
(index_memo, compression_parent, parents, record_details).
index_memo
opaque structure to pass to read_records to extract the raw
data
compression_parent
Content that this record is built upon, may be None
parents
Logical parents of this node
record_details
extra information about the content which needs to be passed to
Factory.parse_record
i i i i Re s
line-deltaRk ( N( R' RW R RQ RP R Rj t _node_to_position(
R! R R t entriesR5 R> RE t compression_parent_keyRi R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRF s&
c c@ s t | } t } | j rT x~ | j j | D] } | V| j | d q1 WnK xH | j j | D]4 } | d | d | d d f V| j | d qg W| r | j | } | r t | j | q n d S( sY Get the entries for keys.
:param keys: An iterable of index key tuples.
i i i N( ( R RQ RO t iter_entriesR RM R RN ( R! R t
check_presentt
found_keysRe R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRW s c C@ s | j | j | S( s+ Return compression method of specified key.( t _get_methodt _get_node( R! R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR= s c C@ s( | j s
d S| j | r d Sd Sd S( NRk s
line-delta( RP Rj ( R! Re ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRq s
c C@ sE y t | j | g d SWn t k
r@ t | | n Xd S( Ni ( R RW t
IndexErrorR ( R! R> ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRr s
c C@ sI | j | } | j | g } | d d d k rE | j d n | S( sI Return a list representing options.
e.g. ['foo', 'bar']
i i Re s no-eol( Rr Rq R ( R! R> Re R2 ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR+ s
c C@ s | j j | d S( s& See CombinedGraphIndex.find_ancestry()i ( RO R4 ( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR4 s c C@ su | j | j | } i } | j rR xF | D] } | d d | | d <q/ Wn x | D] } d | | d <qY W| S( s Get a map of the parents of keys.
:param keys: The keys to look up parents for.
:return: A mapping from keys to parents. Absent keys are absent from
the mapping.
i i i N( R' RW RQ R ( R! R t nodesR Re ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR' s
c C@ s | j | } | j | S( s Return details needed to access the version.
:return: a tuple (index, data position, size) to hand to the access
logic to get the record.
( Rr Rk ( R! R> Re ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR, s c C@ s. | j g | j j D] } | d ^ q S( sO Get all the keys in the collection.
The keys are not ordered.
i ( R' RO Rc ( R! Re ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s
c C@ s< | d d j d } | d t | d t | d f S( s+ Convert an index value to position details.i i Rf i ( R R ( R! Re t bits( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyRk ! s c @ s f d } | j d | S( su Figure out an optimal order to read the records for the given keys.
Sort keys, grouped by index and sorted by position.
:param keys: A list of keys whose records we want to read. This will be
sorted 'in-place'.
:param positions: A dict, such as the one returned by
_get_components_positions()
:return: None
c @ s | d S( Ni ( ( R> ( R ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt get_index_memo1 s R> ( Rd ( R! R R Rv ( ( R s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR & s N(! R$ R% R& R R8 R R# R R, R R Rh R' R Rj RF RW R= Rq Rr R+ R4 R' R, R RL R R RM R Rk R R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR
s6 # Y * R c B@ s2 e Z d Z d Z d Z d Z d Z RS( s! Access to records in .knit files.c C@ s | | _ | | _ d S( s Create a _KnitKeyAccess with transport and mapper.
:param transport: The transport the access object is rooted at.
:param mapper: The mapper used to map keys to .knit files.
N( R R ( R! R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# @ s c C@ s t | t k r+ t d t | n g } d } x | D] \ } } | j j | } y( | j j | d | | | | ! } WnQ t j k
r | j j t
j | | j j | d | | | | ! } n X| | 7} | j | | | f q> W| S( s
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 _KnitKeyAccess the memo is (key, pos,
length), where the key is the record key.
s data must be plain bytes was %si s .knit(
R R# R R R R R R R t mkdirR t dirnameR ( R! t key_sizesR R R R> R2 R t base( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR+ I s"
c C@ s d S( sf Flush pending writes on this access object.
For .knit files this is a no-op.
N( ( R! ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR m s c
c@ s g } d } xx | D]p \ } } } | | d k rH | j | | f q | d k rj | j | | f n | d } | | f g } q W| d k r | j | | f n xU | D]M \ } } | j j | d }
x( | j j |
| D] \ } } | Vq Wq Wd S( s Get the raw bytes for a records.
:param memos_for_retrieval: An iterable containing the access memo for
retrieving the bytes.
:return: An iterator over the bytes of the records.
is .knitN( R R R R R t readv(
R! t memos_for_retrievalt
request_listst current_prefixR> R t lengtht current_listR t read_vectorR R Rc ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR t s
"( R$ R% R& R# R+ R R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR = s
$ c C@ s t | } t | j | S( s Annotate a knit with no cached annotations.
This implementation is for knits with no cached annotations.
It will work for knits with cached annotations, but this is not
recommended.
( R R R ( R_ t revision_idR ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt
annotate_knit s R c B@ sb e Z d Z d Z d Z d
d Z d Z d Z d Z d Z
d Z d Z RS( s$ Build up the annotations for a text.c C@ sM t j j | | i | _ i | _ i | _ i | _ i | _ i | _ d S( N( R t AnnotatorR# t _matching_blockst _content_objectst _num_compression_childrent _pending_deltast _pending_annotationt _all_build_details( R! R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR# s c C@ s t | g } g } t } d | j | <x=| rj| } | j j j | } | j j | t } x | j D] \ } } | \ } } }
} |
| j | <d | _
| j | | f | j g |
D] } | | j k r | ^ q |
r7xC |
D]8 }
|
| j k r#| j |
c d 7<q d | j |
<q Wn | ru | | j k rb| j | c d 7<qrd | j | <qu qu W| j
| j } | r. x | D] } | | j k rK| | j k rK| j | | j | }
x@ |
D]8 }
|
| j k r| j |
c d 7<qd | j |
<qW| j g |
D] } | | j k r&| ^ q& qt j | | j qWq. q. W| j | | f S( s Get the graphs for building texts and annotations.
The data you need for creating a full text may be different than the
data you need to annotate that text. (At a minimum, you need both
parents to create an annotation, but only need 1 parent to generate the
fulltext.)
:return: A list of (key, index_memo) records, suitable for
passing to read_records_iter to start reading in the raw data from
the pack file.
i N( R t _num_needed_childrent _vfR RF R RY RL t _parent_mapR t _heads_providerR R RM R t _text_cacheR R R t reverse( R! R> R Rm t ann_keyst this_iterationR\ RS R
RN R R R3 R t missing_versions( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _get_build_graph sP
c c@ sQ t | j j d k rG x( t j j | | d | D] } | Vq4 Wd Sxt rLy | j | \ } } xh t | j | D]Q \ } \ } } } | d k r | j t d | t | n | | | f Vq~ Wx5 | D]- } | j
| } t | } | | | f Vq Wd SWqJ t j k
rH}
| j j j |
| j j qJ XqJ Wd S( Ni R t
annotating( R R R R R t _get_needed_textsR8 R R t _extract_textsR RY R R R Rh R
Ri R t clear( R! R> R t vRm R t idxt sub_keyR, R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s( " % "
c C@ s? | j | } t t j | | | } | | j | | f <d S( N( R R R R R ( R! R> RN R: R t parent_linest blocks( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _cache_delta_blocks
s
c C@ sg d } | r | | j k rG | j j | g j | | | | f d S| j | } | d 8} | d k r | j j | } | j j | n | | j | <| j | } | j j j | | | | d t
\ } } n$ | j j j | | | d \ } }
| j j | d d k r%| | j | <n | j } | | j
| <| d k rc| j | | | | n | S( Ni i R ( R R R R R R RN R R R= R8 Rl R, R R ( R! R> R RN R R R: t numR R1 RV R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _expand_record
s2
c C@ s] | | f } | | j k rD | j j | } | j | } | | f St j j | | | | S( s Get the list of annotations for the parent, and the matching lines.
:param text: The opaque value given by _get_needed_texts
:param parent_key: The key for the parent text
:return: (parent_annotations, matching_blocks)
parent_annotations is a list as long as the number of lines in
parent
matching_blocks is a list of (parent_idx, text_idx, len) tuples
indicating which lines match between the two texts
( R RN t _annotations_cacheR R t# _get_parent_annotations_and_matches( R! R> R, R t block_keyR t parent_annotations( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR :
s
c C@ s g } | | j k r | } | j j | } xZ | D]O \ } } } } | j | | | | | } | j | | r4 | j | q4 q4 Wn | | j k r | j j | } | j g | D]$ \ }
} | j |
| r |
^ q n | S( sx The content for 'key' was just processed.
Determine if there is any more pending work to be processed.
( R RN R t _check_ready_for_annotationsR R R ( R! R> t to_returnRN t childrent child_keyR R R R R t p_keys( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt _process_pendingM
s "c C@ sJ xC | D]; } | | j k r | j j | g j | | f t Sq Wt S( s return true if this text is ready to be yielded.
Otherwise, this will return False, and queue the text into
self._pending_annotation
( R R R R R R8 ( R! R> R R ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR d
s
c c@ s i } x| j j | D] \ } } } | j | } | \ } } } }
| j | | | | |
} | d k rt q n | j | | } | r | | t | f Vn | j | }
x^ |
r|
} g }
xE | D]= } | j | } | | t | f V|
j | j | q Wq Wq Wd S( s1 Extract the various texts needed based on recordsN(
R R R R R R R R R R ( R! Rm t pending_deltasR> R R- RS RV RN R R R t yield_this_textt
to_processt this_process( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR t
s( "
N(
R$ R% R& R# R R R R R R R R R ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyR s B ' ( t _load_data_c( t
_load_data_py(O R& t
__future__R t cStringIOR t itertoolsR Re R= t bzrlib.lazy_importR t globalst bzrlibR R R t
bzrlib.errorsR R R R
R R t bzrlib.osutilsR
R R R t bzrlib.versionedfileR R R R R R R t DATA_SUFFIXt INDEX_SUFFIXR t objectR R' R5 R; RA RS RU RW Rs R} R R R RK R R R R R R R R R RV R{ R R R R R R t bzrlib._knit_load_data_pyxR RF t ImportErrorR t failed_to_load_extensiont bzrlib._knit_load_data_pyR ( ( ( s/ /usr/lib/python2.7/dist-packages/bzrlib/knit.pyt <module>4 sr ."4 P, 8)%"z? % .Y aR
Copyright © 2017 || Recoded By Mr.Bumblebee