-=[ Mr. Bumblebee ]=-
_Indonesia_
\,Tc @ s d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z e j
Z e j Z
d Z d Z d Z d Z d Z d Z d Z d Z d
Z i Z dA d Z d e f d
YZ d e f d YZ d e f d YZ d Z e d Z d Z 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 Z' e d! d" Z( e d# dB d& Z( e d' d( Z( e d) d* Z) e d+ d, Z* e d- dC d0 Z* e d1 dD d4 Z* e d5 dE d6 Z* e d7 dF d9 Z+ e d: dG d> Z, e d? dH d@ Z- d S(I s Handling of the new bundle2 format
The goal of bundle2 is to act as an atomically packet to transmit a set of
payloads in an application agnostic way. It consist in a sequence of "parts"
that will be handed to and processed by the application layer.
General format architecture
===========================
The format is architectured as follow
- magic string
- stream level parameters
- payload parts (any number)
- end of stream marker.
the Binary format
============================
All numbers are unsigned and big-endian.
stream level parameters
------------------------
Binary format is as follow
:params size: (16 bits integer)
The total number of Bytes used by the parameters
:params value: arbitrary number of Bytes
A blob of `params size` containing the serialized version of all stream level
parameters.
The blob contains a space separated list of parameters. Parameters with value
are stored in the form `<name>=<value>`. Both name and value are urlquoted.
Empty name are obviously forbidden.
Name MUST start with a letter. If this first letter is lower case, the
parameter is advisory and can be safely ignored. However when the first
letter is capital, the parameter is mandatory and the bundling process MUST
stop if he is not able to proceed it.
Stream parameters use a simple textual format for two main reasons:
- Stream level parameters should remain simple and we want to discourage any
crazy usage.
- Textual data allow easy human inspection of a bundle2 header in case of
troubles.
Any Applicative level options MUST go into a bundle2 part instead.
Payload part
------------------------
Binary format is as follow
:header size: (16 bits inter)
The total number of Bytes used by the part headers. When the header is empty
(size = 0) this is interpreted as the end of stream marker.
:header:
The header defines how to interpret the part. It contains two piece of
data: the part type, and the part parameters.
The part type is used to route an application level handler, that can
interpret payload.
Part parameters are passed to the application level handler. They are
meant to convey information that will help the application level object to
interpret the part payload.
The binary format of the header is has follow
:typesize: (one byte)
:parttype: alphanumerical part name
:partid: A 32bits integer (unique in the bundle) that can be used to refer
to this part.
:parameters:
Part's parameter may have arbitrary content, the binary structure is::
<mandatory-count><advisory-count><param-sizes><param-data>
:mandatory-count: 1 byte, number of mandatory parameters
:advisory-count: 1 byte, number of advisory parameters
:param-sizes:
N couple of bytes, where N is the total number of parameters. Each
couple contains (<size-of-key>, <size-of-value) for one parameter.
:param-data:
A blob of bytes from which each parameter key and value can be
retrieved using the list of size couples stored in the previous
field.
Mandatory parameters comes first, then the advisory ones.
Each parameter's key MUST be unique within the part.
:payload:
payload is a series of `<chunksize><chunkdata>`.
`chunksize` is a 32 bits integer, `chunkdata` are plain bytes (as much as
`chunksize` says)` The payload part is concluded by a zero size chunk.
The current implementation always produces either zero or one chunk.
This is an implementation limitation that will ultimately be lifted.
Bundle processing
============================
Each part is processed in order using a "part handler". Handler are registered
for a certain part type.
The matching of a part to its handler is case insensitive. The case of the
part type is used to know if a part is mandatory or advisory. If the Part type
contains any uppercase char it is considered mandatory. When no handler is
known for a Mandatory part, the process is aborted and an exception is raised.
If the part is advisory and no handler is known, the part is ignored. When the
process is aborted, the full bundle is still read from the stream to keep the
channel usable. But none of the part read from an abort are processed. In the
future, dropping the stream may become an option for channel we do not care to
preserve.
iN( t _t HG2Xs >Hs >Bs >Is >BBi c C s d d | S( s return a struct format to read part parameter sizes
The number parameters is variable so we need to build that format
dynamically.
t >t BB( ( t nbparams( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt _makefpartparamsizes s c s f d } | S( s decorator that register a function as a bundle2 part handler
eg::
@parthandler('myparttype', ('mandatory', 'param', 'handled'))
def myparttypehandler(...):
'''process a part of type "my part".'''
...
c s; j } | t k s t | t | <t | _ | S( N( t lowert parthandlermappingt AssertionErrort frozensett params( t funct lparttype( R
t parttype( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
_decorator s
( ( R
R
R ( ( R
R
s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt parthandler s
t unbundlerecordsc B sP e Z d Z d Z d d Z d Z d Z d Z d Z d Z
RS( s keep record of what happens during and unbundle
New records are added using `records.add('cat', obj)`. Where 'cat' is a
category of record and obj is an arbitrary object.
`records['cat']` will return all entries of this category 'cat'.
Iterating on the object itself will yield `('category', obj)` tuples
for all entries.
All iterations happens in chronological order.
c C s i | _ g | _ i | _ d S( N( t _categoriest
_sequencest _replies( t self( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __init__ s c C s^ | j j | g j | | j j | | f | d k rZ | j | j | | n d S( s add a new record of a given category.
The entry can then be retrieved in the list returned by
self['category'].N( R t
setdefaultt appendR t Nonet
getrepliest add( R t categoryt entryt inreplyto( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s | j j | t S( s2 get the subrecords that replies to a specific part( R R R ( R t partid( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s t | j j | d S( N( ( t tupleR t get( R t cat( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __getitem__ s c C s
t | j S( N( t iterR ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __iter__ s c C s
t | j S( N( t lenR ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __len__ s c C s
t | j S( N( t boolR ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __nonzero__ s N( t __name__t
__module__t __doc__R R R R R" R$ R& R( ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s
t bundleoperationc B s e Z d Z d Z RS( sP an object that represents a single bundling process
Its purpose is to carry unbundle-related objects and states.
A new object should be created at the beginning of each bundle processing.
The object is to be returned by the processing function.
The object has very little content now it will ultimately contain:
* an access to the repo the bundle is applied to,
* a ui object,
* a way to retrieve a transaction to add changes to the repo,
* a way to record the result of processing each part,
* a way to construct a bundle response when applicable.
c C s7 | | _ | j | _ t | _ | | _ d | _ d S( N( t repot uiR t recordst gettransactionR t reply( R R- t transactiongetter( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s
( R) R* R+ R ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR, s t TransactionUnavailablec B s e Z RS( ( R) R* ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR3 s c C s
t d S( s default method to get a transaction while processing a bundle
Raise an exception to highlight the fact that no transaction was expected
to be createdN( R3 ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt _notransaction s c
C s5 t | | } | j | j } d } yx| D]} | j } | j } y t j | } | d k r t j d | n | j
j d | | j | j } | r t
| } | j t j d | d | n WnI t j k
r'}
| | k r n | j
j d |
| j q2 n Xd } | j d k rY| j
j d t d } n z | | | Wd | d k r| j
j } n X| r| j j d d | } | j d
t | j d t n | j q2 WWnS t k
r0}
| d k r| j n x | D] } | j q
Wt |
_ n X| S( sg This function process a bundle, apply effect to/from a repo
It iterates over each part then searches for and uses the proper handling
code to process the part. Parts are processed in order.
This is very early version of this function that will be strongly reworked
before final usage.
Unknown Mandatory part will abort the process.
R
s found a handler for part %r
R
s& ignoring unsupported advisory part %s
t errort Ns
b2x:outputt datas in-reply-tot mandatory( R, R
t iterpartsR t typeR R R R5 t BundleValueErrorR. t debugt
mandatorykeyst listt sortt readR1 t
pushbuffert Truet popbuffert newpartt addparamt strt idt Falset Exceptiont duringunbundle2(
R- t unbundlerR2 t opR9 t partR
t keyt handlert
unknownparamst exct outputt outpart( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
processbundle sZ
"
c C s i } x | j D] } | s% q n d | k rA | d } } n' | j d d \ } } | j d } t j | } g | D] } t j | ^ q~ } | | | <q W| S( s decode a bundle2 caps bytes blob into a dictionnary
The blob is a list of capabilities (one per line)
Capabilities may have values using a line of the form::
capability=value1,value2,value3
The values are always a list.t =i t ,( ( t
splitlinest splitt urllibt unquote( t blobt capst lineRN t valst v( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
decodecaps^ s "c C s g } x~ t | D]p } | | } t j | } g | D] } t j | ^ q9 } | rv d | d j | f } n | j | q Wd j | S( s2 encode a bundle2 caps dictionary into a bytes blobs %s=%sRV s
( t sortedRY t quotet joinR ( R\ t chunkst caR^ R_ ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
encodecapsu s
" t bundle20c B sY e Z d Z d d Z e d Z d d Z d Z d Z d Z
d Z RS(
s represent an outgoing bundle2 container
Use the `addparam` method to add stream level parameter. and `newpart` to
populate it. Then call `getchunks` to retrieve all the binary chunks of
data that compose the bundle2 container.c C s. | | _ g | _ g | _ t | | _ d S( N( R. t _paramst _partst dictt capabilities( R R. Rk ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s
t | j S( s* total number of parts added to the bundler( R% Ri ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt nbparts s c C sU | s t d n | d t j k r; t d | n | j j | | f d S( s add a stream level parameters empty parameter namei s non letter first character: %rN( t
ValueErrort stringt lettersRh R ( R t namet value( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyRE s
c C s; | j d k s t t | j | _ | j j | d S( s_ add a new part to the bundle2 container
Parts contains the actual applicative payload.N( RG R R R% Ri R ( R RM ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt addpart s c O s# t | | | } | j | | S( sq create a new part and add it to the containers
As the part is directly added to the containers. For now, this means
that any failure to properly initialize the part after calling
``newpart`` should result in a failure of the whole bundling process.
You can still fall back to manually create and add if you need better
control.( t
bundlepartRr ( R t typeidt argst kwargsRM ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyRD s
c c s | j j d t t V| j } | j j d | t t t | V| r[ | Vn | j j d xD | j D]9 } | j j d | j x | j D] } | Vq Wqu W| j j d d Vd S( Ns start emission of %s stream
s bundle parameter: %s
s start of parts
s bundle part: "%s"
s end of bundle
t (
R. R< t _magicstringt _paramchunkt _packt _fstreamparamsizeR% Ri R: t getchunks( R t paramRM t chunk( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR| s
c C sw g } xa | j D]V \ } } t j | } | d k rY t j | } d | | f } n | j | q Wd j | S( s1 return a encoded version of all stream parameterss %s=%st N( Rh RY Rb R R Rc ( R t blockst parRq ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyRy s ( N( R) R* R+ R t propertyRl R RE Rr RD R| Ry ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyRg s t
unpackermixinc B s) e Z d Z d Z d Z d Z RS( s6 A mixin to extract bytes and struct data from a streamc C s
| | _ d S( N( t _fp( R t fp( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s% | j t j | } t | | S( s) unpack this struct format from the stream( t
_readexactt structt calcsizet _unpack( R t formatR7 ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s t j | j | S( s) read exactly <size> bytes from the stream( t changegroupt readexactlyR ( R t size( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s ( R) R* R+ R R R ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s t
unbundle20c B sG e Z d Z d d Z e j d Z d Z d Z d Z
RS( s| interpret a bundle2 stream
This class is fed with a binary stream and yields parts through its
`iterparts` methods.c C s | | _ t t | j | | d k r | j d } | d d !| d d !} } | d k ry t j t d n | d k r t j t d | q n | j j d | d S(
s< If header is specified, we do not read it out of the stream.i i i t HGs not a Mercurial bundlet 2Xs unknown bundle version %ss start processing of %s stream
N(
R. t superR R R R t utilt AbortR R< ( R R. R t headert magict version( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s | j j d i } | j t d } | r x | j | j d D]{ } | j d d } g | D] } t j | ^ qg } t | d k r | j d n | j | | d | | d <qH Wn | S( s% dictionary of stream level parameterss" reading bundle2 stream parameters
i R RU i i N( R. R< R R{ R RX RY RZ R% R R t
_processparam( R R
t
paramssizet pt i( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR
s "
c C s{ | s t d n | d t j k r; t d | n | d j rb | j j d | n t j d | f d S( s process a parameter, applying its effect if needed
Parameter starting with a lower case letter are advisory and will be
ignored when unknown. Those starting with an upper case letter are
mandatory and will this function will raise a KeyError when unknown.
Note: no option are currently supported. Any input will be either
ignored or failing.
s empty parameter namei s non letter first character: %rs ignoring unknown parameter %r
R
N( Rm Rn Ro t islowerR. R< R5 R; ( R Rp Rq ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s
c c ss | j | j j d | j } x9 | d k r^ t | j | | j } | V| j } q& W| j j d d S( s' yield all parts contained in the streams" start extraction of bundle2 parts
s end of bundle2 stream
N( R
R. R< t _readpartheaderR t unbundlepartR ( R t headerblockRM ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR9 s c C s> | j t d } | j j d | | r: | j | Sd S( sQ reads a part header size and return the bytes blob
returns None if emptyi s part header size: %i
N( R t _fpartheadersizeR. R< R R ( R t
headersize( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR # s
N( R) R* R+ R R R t
propertycacheR
R R9 R ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s
Rs c B s e Z d Z d
d d d Z d Z d Z e e e Z e d Z e d Z d e
d Z d Z d Z
RS( s A bundle2 part contains application level payload
The part `type` is used to route the part to the application level
handler.
The part payload is contained in ``part.data``. It could be raw bytes or a
generator of byte chunks.
You can add parameters to the part using the ``addparam`` method.
Parameters can be either mandatory (default) or advisory. Remote side
should be able to safely ignore the advisory ones.
Both data and parameters cannot be modified after the generation has begun.
R6 c C s d | _ | | _ | | _ t | | _ t | | _ t | _ xP | j | j D]> \ } } | | j k r t d | n | j j
| qV Wd | _ d S( Ns duplicated params: %s( R RG R: t _dataR> t _mandatoryparamst _advisoryparamst sett _seenparamst RuntimeErrorR t
_generated( R R
t mandatoryparamst advisoryparamsR7 t pnamet __( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR > s c C s. | j d k r! t j d n | | _ d S( Ns part is being generated( R R R5 t ReadOnlyPartErrorR ( R R7 ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __setdataR s c C s | j S( N( R ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt __getdataV s c C s
t | j S( N( R R ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR Z s c C s
t | j S( N( R R ( R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR _ s c C s | j d k r! t j d n | | j k rC t d | n | j j | | j } | rn | j } n | j | | f d S( Ns part is being generateds duplicated params: %s(
R R R5 R R Rm R R R R ( R Rp Rq R8 R
( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyRE d s c
c s | j d k r t d n t | _ t t t | j | j t t | j g } | j
} | j } | j t t
t | t | g } x: | D]2 \ } } | j t | | j t | q Wx: | D]2 \ } } | j t | | j t | q Wt t t | d | } | j | x. | D]& \ } } | j | | j | qAWx. | D]& \ } } | j | | j | qrWd j | } t t t | V| Vx- | j D] } t t t | V| VqWt t d Vt | _ d S( Ns part can only be consumed oncei R6 i ( R R R RH Rz t _fparttypesizeR% R: t _fpartidRG R R R t _fpartparamcountR Rc R t _payloadchunkst
_fpayloadsizeRB (
R R t manpart advpart parsizesRN Rq t
paramsizest headerchunkR~ ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR| p s> %
c c sx t j | j d rZ t j | j } | j t } x; | rV | V| j t } q9 Wn t | j rt | j Vn d S( sm yield chunks of a the part payload
Exists to handle the different methods to provide data to a part.t nextN( R t safehasattrR7 t chunkbufferR@ t preferedchunksizeR% ( R t buffR~ ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s ( ( ( R) R* R+ R t _bundlepart__setdatat _bundlepart__getdataR R7 R R RB RE R| R ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyRs . s +R c B sG e Z d Z d Z d Z d Z d Z d Z d d Z RS( s a bundle part read from a bundlec C s t t | j | | | _ | | _ d | _ t | _ t | _ d | _
d | _ d | _ d | _
d | _ d | _ d | _ | j d S( Ni ( ( R R R R. t _headerdatat
_headeroffsetRH t _initializedt consumedR RG R: R R R
R= t _payloadstreamt _readheader( R R. R R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s c C s. | j } | j | | | !} | | | _ | S( s+ return the next <size> byte from the header( R R ( R R t offsetR7 ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt _fromheader s
c C s% | j t j | } t | | S( sa read given format from header
This automatically compute the size of the format to read.( R R R R ( R R R7 ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
_unpackheader s c C sf t | | _ t | | _ t | j | _ | j j t | j t d | D | _ d S( s7 internal function to setup all logic related parametersc s s | ] } | d Vq d S( i N( ( t .0R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pys <genexpr> s N( R R R Rj R
t updateR R= ( R R R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt _initparams s
c
s j t d } j | _ j j d j j t d _ j j d j j t \ } } j j d | | t | | } j | } t
| d d d | d d d } | | } | | } g } x9 | D]1 \ } }
| j j | j |
f q Wg } x9 | D]1 \ } }
| j j | j |
f qAW j | | f d } t
j | _ t _ d S( s$ read the header and setup the objecti s part type: "%s"
s part id: "%s"
s part parameters: %i
Ni i c 3 sm j t d } j j d | x? | rh j | V j t d } j j d | q* Wd S( Ni s payload chunk size: %i
( R R R. R< R ( t payloadsize( R ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
payloadchunks s ( R R R R: R. R< R RG R R t zipR R R R R RB R (
R t typesizet mancountt advcountt fparamsizesR t mansizest advsizest manparamsRN Rq t advparamsR ( ( R s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s, )
))c C st | j s | j n | d k r4 | j j } n | j j | } | d k sd t | | k rp t | _ n | S( s read payload dataN( R R R R R@ R% RB R ( R R R7 ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR@ s
N(
R) R* R+ R R R R R R R@ ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR s
'c C sH | j d } | r& | d k r& i St j | j d } t | S( s/ return the bundlecapabilities of a peer as dicts bundle2-expR6 ( t capableRY RZ R` ( t remotet rawt capsblob( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt bundle2caps
s
s b2x:changegroupc C s | j t j | d } t j | j | d d } | j j d i | d 6 | j d k r | j j d } | j
d t | j d t
| j
d d | d t
n | j s t d S(
s apply a changegroup part on the repo
This is a very early implementation that will massive rework before being
inflicted to any end-user.
t UNt bundle2R t returns b2x:reply:changegroups in-reply-toR8 s %iN( R0 R t
unbundle10t addchangegroupR- R/ R R1 R RD RE RF RG RH R@ R ( RL t inpartt cgt retRM ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt handlechangegroup s
s b2x:reply:changegroupR s in-reply-toc C sG t | j d } t | j d } | j j d i | d 6| d S( NR s in-reply-toR ( t intR
R/ R ( RL R R t replyto( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR * s s b2x:check:headsc C s | j d } g } x2 t | d k rI | j | | j d } q W| sW t | | j j k r~ t j d n d S( s check that head of the repo did not change
This is used to detect a push race when using unbundle.
This replaces the "heads" argument of unbundle.i s3 repository changed while pushing - please try againN( R@ R% R R R- t headsR5 t PushRaced( RL R t hR ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR 0 s
s
b2x:outputc C s5 x. | j j D] } | j j d | q Wd S( s3 forward output captured on the server to the clients remote: %s
N( R@ RW R. t write( RL R R] ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt handleoutput@ s s
b2x:replycapsc C s= t | j } | j d k r9 t | j | | _ n d S( sq Notify that a reply bundle should be created
The payload contains the capabilities information for the replyN( R` R@ R1 R Rg R. ( RL R R\ ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt handlereplycapsF s s b2x:error:abortt messaget hintc C s, t j | j d d | j j d d S( s* Used to transmit abort error over the wireR R N( R R R
R ( RL R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR O s s b2x:error:unsupportedcontentR
R
c C sx i } | j j d } | d k r1 | | d <n | j j d } | d k re | j d | d <n t j | d S( s4 Used to transmit unknown content error over the wireR
R
t N( R
R R RX R5 R; ( RL R Rv R
R
( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR T s
s b2x:error:pushracedc C s# t j t d | j d d S( s. Used to transmit push race error over the wires push failed:R N( R5 t
ResponseErrorR R
( RL R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyR a s s b2x:listkeyst namespacec C s? | j d } t j | j } | j j d | | f d S( s6 retrieve pushkey namespace content stored in a bundle2R t listkeysN( R
t pushkeyt
decodekeysR@ R/ R ( RL R R t r( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt handlelistkeysf s
s b2x:pushkeyRN t oldt newc
C s t j } | | j d } | | j d } | | j d } | | j d } | j j | | | | } i | d 6| d 6| d 6| d 6} | j j d | | j d k r| j j d } | j d t
| j d t | j d d
| d t n d S( s process a pushkey requestR RN R R R s b2x:reply:pushkeys in-reply-toR8 R s %iN(
R t decodeR
R- R/ R R1 R RD RE RF RG RH (
RL R t decR RN R R R t recordt rpart( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt
handlepushkeym s
s b2x:reply:pushkeyc C sG t | j d } t | j d } | j j d i | d 6| d S( s( retrieve the result of a pushkey requestR s in-reply-toR N( R R
R/ R ( RL R R R ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt handlepushkeyreply s ( ( s returns in-reply-to( s messages hint( s parttypes params( s message( s namespace( s namespaces keys olds new( s returns in-reply-to(. R+ R R RY Rn R R R5 t i18nR t packRz t unpackR Rx R{ R R R R R R R R R t objectR R, R R3 R4 RT R` Rf Rg R R Rs R R R R R R R R ( ( ( s5 /usr/lib/python2.7/dist-packages/mercurial/bundle2.pyt <module> sX - L MP|`
Copyright © 2017 || Recoded By Mr.Bumblebee