Your IP : 172.28.240.42
{|Nc @ sF d Z e Z d d l Z d d l Z d d l m Z d d l m Z d d l Z d d l
Z
d d l m Z m
Z
d d l m Z d d l m Z d d l m Z d d l m Z d d
l m Z m Z d d l m Z d d l m Z m Z d d
l m Z d d l m Z m! Z! m" Z" d d l# m$ Z$ m% Z% y d d l& m' Z' Wn e( k
r]e) Z' n Xe' oke' j* rwe) Z' n e' e) k rd d l+ m, Z, m- Z- m. Z. m/ Z/ n d Z0 d Z1 d Z2 d Z3 d Z4 d Z5 d Z6 d Z7 d Z8 d Z9 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) YZA d* e? f d+ YZB d, e? f d- YZC d. e? f d/ YZD d0 e? f d1 YZE d2 e? f d3 YZF d4 eF f d5 YZG d6 e? f d7 YZH d8 e? f d9 YZI d: e? f d; YZJ i eI e7 6ZK d< eL f d= YZM eM ZN d> eM f d? YZO d@ eM f dA YZP dB f dC YZQ dD f dE YZR dF eS f dG YZT dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` da db dc dd g ZU de ZV df f dg YZW dh eW f di YZX dj eW f dk YZY dl eW f dm YZZ dn eW f do YZ[ dp eY f dq YZ\ dr e\ f ds YZ] dt eW f du YZ^ dv eW f dw YZ_ dx f dy YZ` dz f d{ YZa d| eM f d} YZb d~ eY f d YZc d e` f d YZd d e` f d YZe d e% e$ f d YZf d ef eQ eR eT f d YZg d f d YZh eh ji Zi eh jj Zj d Zk d Zl d e
jm f d YZn en d d d Zo d eW f d YZp d eW f d YZq d S( s
This module implements AMP, the Asynchronous Messaging Protocol.
AMP is a protocol for sending multiple asynchronous request/response pairs over
the same connection. Requests and responses are both collections of key/value
pairs.
AMP is a very simple protocol which is not an application. This module is a
"protocol construction kit" of sorts; it attempts to be the simplest wire-level
implementation of Deferreds. AMP provides the following base-level features:
- Asynchronous request/response handling (hence the name)
- Requests and responses are both key/value pairs
- Binary transfer of all data: all data is length-prefixed. Your
application will never need to worry about quoting.
- Command dispatching (like HTTP Verbs): the protocol is extensible, and
multiple AMP sub-protocols can be grouped together easily.
The protocol implementation also provides a few additional features which are
not part of the core wire protocol, but are nevertheless very useful:
- Tight TLS integration, with an included StartTLS command.
- Handshaking to other protocols: because AMP has well-defined message
boundaries and maintains all incoming and outgoing requests for you, you
can start a connection over AMP and then switch to another protocol.
This makes it ideal for firewall-traversal applications where you may
have only one forwarded port but multiple applications that want to use
it.
Using AMP with Twisted is simple. Each message is a command, with a response.
You begin by defining a command type. Commands specify their input and output
in terms of the types that they expect to see in the request and response
key-value pairs. Here's an example of a command that adds two integers, 'a'
and 'b'::
class Sum(amp.Command):
arguments = [('a', amp.Integer()),
('b', amp.Integer())]
response = [('total', amp.Integer())]
Once you have specified a command, you need to make it part of a protocol, and
define a responder for it. Here's a 'JustSum' protocol that includes a
responder for our 'Sum' command::
class JustSum(amp.AMP):
def sum(self, a, b):
total = a + b
print 'Did a sum: %d + %d = %d' % (a, b, total)
return {'total': total}
Sum.responder(sum)
Later, when you want to actually do a sum, the following expression will return
a L{Deferred} which will fire with the result::
ClientCreator(reactor, amp.AMP).connectTCP(...).addCallback(
lambda p: p.callRemote(Sum, a=13, b=81)).addCallback(
lambda result: result['total'])
Command responders may also return Deferreds, causing the response to be
sent only once the Deferred fires::
class DelayedSum(amp.AMP):
def slowSum(self, a, b):
total = a + b
result = defer.Deferred()
reactor.callLater(3, result.callback, {'total': total})
return result
Sum.responder(slowSum)
This is transparent to the caller.
You can also define the propagation of specific errors in AMP. For example,
for the slightly more complicated case of division, we might have to deal with
division by zero::
class Divide(amp.Command):
arguments = [('numerator', amp.Integer()),
('denominator', amp.Integer())]
response = [('result', amp.Float())]
errors = {ZeroDivisionError: 'ZERO_DIVISION'}
The 'errors' mapping here tells AMP that if a responder to Divide emits a
L{ZeroDivisionError}, then the other side should be informed that an error of
the type 'ZERO_DIVISION' has occurred. Writing a responder which takes
advantage of this is very simple - just raise your exception normally::
class JustDivide(amp.AMP):
def divide(self, numerator, denominator):
result = numerator / denominator
print 'Divided: %d / %d = %d' % (numerator, denominator, total)
return {'result': result}
Divide.responder(divide)
On the client side, the errors mapping will be used to determine what the
'ZERO_DIVISION' error means, and translated into an asynchronous exception,
which can be handled normally as any L{Deferred} would be::
def trapZero(result):
result.trap(ZeroDivisionError)
print "Divided by zero: returning INF"
return 1e1000
ClientCreator(reactor, amp.AMP).connectTCP(...).addCallback(
lambda p: p.callRemote(Divide, numerator=1234,
denominator=0)
).addErrback(trapZero)
For a complete, runnable example of both of these commands, see the files in
the Twisted repository::
doc/core/examples/ampserver.py
doc/core/examples/ampclient.py
On the wire, AMP is a protocol which uses 2-byte lengths to prefix keys and
values, and empty keys to separate messages::
<2-byte length><key><2-byte length><value>
<2-byte length><key><2-byte length><value>
...
<2-byte length><key><2-byte length><value>
<NUL><NUL> # Empty Key == End of Message
And so on. Because it's tedious to refer to lengths and NULs constantly, the
documentation will refer to packets as if they were newline delimited, like
so::
C: _command: sum
C: _ask: ef639e5c892ccb54
C: a: 13
C: b: 81
S: _answer: ef639e5c892ccb54
S: total: 94
Notes:
In general, the order of keys is arbitrary. Specific uses of AMP may impose an
ordering requirement, but unless this is specified explicitly, any ordering may
be generated and any ordering must be accepted. This applies to the
command-related keys I{_command} and I{_ask} as well as any other keys.
Values are limited to the maximum encodable size in a 16-bit length, 65535
bytes.
Keys are limited to the maximum encodable size in a 8-bit length, 255 bytes.
Note that we still use 2-byte lengths to encode keys. This small redundancy
has several features:
- If an implementation becomes confused and starts emitting corrupt data,
or gets keys confused with values, many common errors will be signalled
immediately instead of delivering obviously corrupt packets.
- A single NUL will separate every key, and a double NUL separates
messages. This provides some redundancy when debugging traffic dumps.
- NULs will be present at regular intervals along the protocol, providing
some padding for otherwise braindead C implementations of the protocol,
so that <stdio.h> string functions will see the NUL and stop.
- This makes it possible to run an AMP server on a port also used by a
plain-text protocol, and easily distinguish between non-AMP clients (like
web browsers) which issue non-NUL as the first byte, and AMP clients,
which always issue NUL as the first byte.
iN( t StringIO( t pack( t Interfacet
implements( t set( t
unsignedID( t accumulateClassDict( t Failure( t logt filepath( t CONNECTION_LOST( t PeerVerifyErrort ConnectionLost( t ConnectionClosed( t Deferredt
maybeDeferredt fail( t Int16StringReceivert StatefulStringProtocol( t ssl( t CertificateOptionst Certificatet DNt KeyPairt _askt _answert _commandt _errort _error_codet _error_descriptiont UNKNOWNt UNHANDLEDi i t
IArgumentTypec B s e Z d Z d Z d Z RS( s
An L{IArgumentType} can serialize a Python object into an AMP box and
deserialize information from an AMP box back into a Python object.
@since: 9.0
c C s d S( s
Given an argument name and an AMP box containing serialized values,
extract one or more Python objects and add them to the C{objects}
dictionary.
@param name: The name associated with this argument. Most commonly,
this is the key which can be used to find a serialized value in
C{strings} and which should be used as the key in C{objects} to
associate with a structured Python object.
@type name: C{str}
@param strings: The AMP box from which to extract one or more
values.
@type strings: C{dict}
@param objects: The output dictionary to populate with the value for
this argument.
@type objects: C{dict}
@param proto: The protocol instance which received the AMP box being
interpreted. Most likely this is an instance of L{AMP}, but
this is not guaranteed.
@return: C{None}
N( ( t namet stringst objectst proto( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt fromBox s c C s d S( s
Given an argument name and a dictionary containing structured Python
objects, serialize values into one or more strings and add them to
the C{strings} dictionary.
@param name: The name associated with this argument. Most commonly,
this is the key which can be used to find an object in
C{objects} and which should be used as the key in C{strings} to
associate with a C{str} giving the serialized form of that
object.
@type name: C{str}
@param strings: The AMP box into which to insert one or more
strings.
@type strings: C{dict}
@param objects: The input dictionary from which to extract Python
objects to serialize.
@type objects: C{dict}
@param proto: The protocol instance which will send the AMP box once
it is fully populated. Most likely this is an instance of
L{AMP}, but this is not guaranteed.
@return: C{None}
N( ( R! R" R# R$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt toBox s ( t __name__t
__module__t __doc__R% R& ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s t
IBoxSenderc B s e Z d Z d Z d Z RS( s7
A transport which can send L{AmpBox} objects.
c C s d S( s
Send an L{AmpBox}.
@raise ProtocolSwitched: if the underlying protocol has been
switched.
@raise ConnectionLost: if the underlying connection has already been
lost.
N( ( t box( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt sendBox" s c C s d S( s
An unhandled error occurred in response to a box. Log it
appropriately.
@param failure: a L{Failure} describing the error that occurred.
N( ( t failure( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt unhandledError- s ( R' R( R) R, R. ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR* s t IBoxReceiverc B s) e Z d Z d Z d Z d Z RS( sh
An application object which can receive L{AmpBox} objects and dispatch them
appropriately.
c C s d S( s
The L{ampBoxReceived} method will start being called; boxes may be
responded to by responding to the given L{IBoxSender}.
@param boxSender: an L{IBoxSender} provider.
N( ( t boxSender( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt startReceivingBoxes= s c C s d S( sS
A box was received from the transport; dispatch it appropriately.
N( ( R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt ampBoxReceivedF s c C s d S( si
No further boxes will be received on this connection.
@type reason: L{Failure}
N( ( t reason( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt stopReceivingBoxesL s ( R' R( R) R1 R2 R4 ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR/ 7 s t IResponderLocatorc B s e Z d Z d Z RS( se
An application object which can look up appropriate responder methods for
AMP commands.
c C s d S( s
Locate a responder method appropriate for the named command.
@param name: the wire-level name (commandName) of the AMP command to be
responded to.
@return: a 1-argument callable that takes an L{AmpBox} with argument
values for the given command, and returns an L{AmpBox} containing
argument values for the named command, or a L{Deferred} that fires the
same.
N( ( R! ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt locateResponder[ s ( R' R( R) R6 ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR5 U s t AmpErrorc B s e Z d Z RS( s3
Base class of all Amp-related exceptions.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR7 j s t ProtocolSwitchedc B s e Z d Z RS( s
Connections which have been switched to other protocols can no longer
accept traffic at the AMP level. This is raised when you try to send it.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR8 q s t
OnlyOneTLSc B s e Z d Z RS( s`
This is an implementation limitation; TLS may only be started once per
connection.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR9 y s t NoEmptyBoxesc B s e Z d Z RS( st
You can't have empty boxes on the connection. This is raised when you
receive or attempt to send one.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR: s t InvalidSignaturec B s e Z d Z RS( s5
You didn't pass all the required arguments.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR; s t TooLongc B s# e Z d Z d d Z d Z RS( s
One of the protocol's length limitations was violated.
@ivar isKey: true if the string being encoded in a key position, false if
it was in a value position.
@ivar isLocal: Was the string encoded locally, or received too long from
the network? (It's only physically possible to encode "too long" values on
the network for keys.)
@ivar value: The string that was too long.
@ivar keyName: If the string being encoded was in a value position, what
key was it being encoded for?
c C s5 t j | | | _ | | _ | | _ | | _ d S( N( R7 t __init__t isKeyt isLocalt valuet keyName( t selfR> R? R@ RA ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s
c C sg | j r d p d } | j s8 | d t | j 7} n | j rG d pJ d } d | | t | j f S( Nt keyR@ t t localt remotes %s %s too long: %d( R> t reprRA R? t lenR@ ( RB t hdrt lcl( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt __repr__ s
N( R' R( R) t NoneR= RK ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR< s t BadLocalReturnc B s& e Z d Z d Z d Z e Z RS( sU
A bad value was returned from a local command; we were unable to coerce it.
c C s# t j | | | _ | | _ d S( N( R7 R= t messaget enclosed( RB RN RO ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s
c C s | j d | j j S( NRD ( RN RO t getBriefTraceback( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRK s ( R' R( R) R= RK t __str__( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRM s t RemoteAmpErrorc B s e Z d Z e d d Z RS( s
This error indicates that something went wrong on the remote end of the
connection, and the error was serialized and transmitted to you.
c C so | r d } | j } n d } d } t j | d | | | | f | | _ | | _ | | _ | | _ d S( sP Create a remote error with an error code and description.
@param errorCode: the AMP error code of this error.
@param description: some text to show to the user.
@param fatal: a boolean, true if this error should terminate the
connection.
@param local: a local Failure, if one exists.
s (local)t s Code<%s>%s: %s%sN( RP t ExceptionR= RE t errorCodet descriptiont fatal( RB RU RV RW RE t localwhatt othertb( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s N( R' R( R) t FalseRL R= ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRR s t UnknownRemoteErrorc B s e Z d Z d Z RS( sc
This means that an error whose type we can't identify was raised from the
other side.
c C s t } t j | | | d S( N( t UNKNOWN_ERROR_CODERR R= ( RB RV RU ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s ( R' R( R) R= ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR[ s t MalformedAmpBoxc B s e Z d Z RS( sJ
This error indicates that the wire-level protocol was malformed.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR] s t UnhandledCommandc B s e Z d Z RS( s=
A command received via amp could not be dispatched.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR^ s t IncompatibleVersionsc B s e Z d Z RS( sw
It was impossible to negotiate a compatible version of the protocol with
the other end of the connection.
( R' R( R) ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR_ s t AmpBoxc B s8 e Z d Z g Z d Z d Z d Z d Z RS( sT
I am a packet in the AMP protocol, much like a regular str:str dictionary.
c C s | j } | j | | S( s5
Return another AmpBox just like me.
( t __class__t update( RB t newBox( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt copy s
c C s: | j } | j g } | j } x | D] \ } } t | t k r] t d | n t | t k r t d | | f n t | t k r t t t | d n t | t k r t t t | | n x7 | | f D]) } | t
d t | | | q Wq, W| t
d d d j | S( s
Convert me into a wire-encoded string.
@return: a str encoded according to the rules described in the module
docstring.
s Unicode key not allowed: %rs( Unicode value for key %r not allowed: %rs !Hi RS N( t itemst sortt appendt typet unicodet TypeErrorRH t MAX_KEY_LENGTHR< t TrueRL t MAX_VALUE_LENGTHRZ R t join( RB t it Lt wt kt vt kv( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt serialize s&
c C s | j | d S( sV
Serialize and send this box to a Amp instance. By the time it is being
sent, several keys are required. I must have exactly ONE of::
_ask
_answer
_error
If the '_ask' key is set, then the '_command' key must also be
set.
@param proto: an AMP instance.
N( R, ( RB R$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _sendTo3 s c C s d t j | f S( Ns
AmpBox(%s)( t dictRK ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRK C s ( R' R( R) t __slots__Rd Ru Rv RK ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR` s t QuitBoxc B s& e Z d Z g Z d Z d Z RS( sJ
I am an AmpBox that, upon being sent, terminates the connection.
c C s d t t | j f S( Ns
QuitBox(**%s)( t superRy RK ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRK Q s c C s' t t | j | | j j d S( s@
Immediately call loseConnection after sending.
N( Rz Ry Rv t transportt loseConnection( RB R$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRv U s ( R' R( R) Rx RK Rv ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRy J s t
_SwitchBoxc B s) e Z d Z d Z d Z d Z RS( s{
Implementation detail of ProtocolSwitchCommand: I am a AmpBox which sets
up state for the protocol to switch.
c K s# t t | j | | | _ d S( s
Create a _SwitchBox with the protocol to switch to after being sent.
@param innerProto: the protocol instance to switch to.
@type innerProto: an IProtocol provider.
N( Rz R} R= t
innerProto( RB R~ t kw( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= f s c C s d | j t j | f S( Ns _SwitchBox(%r, **%s)( R~ Rw RK ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRK q s c C s4 t t | j | | j | j | j d S( s{
Send me; I am the last box on the connection. All further traffic will be
over the new protocol.
N( Rz R} Rv t _lockForSwitcht _switchToR~ ( RB R$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRv v s
( R' R( R) R= RK Rv ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR} ^ s t
BoxDispatcherc B s e Z d Z e e d Z d Z d Z d Z d Z
d Z d Z d Z
d Z e d Z e d Z d Z d
Z d Z d Z d
Z d Z d Z d Z RS( s
A L{BoxDispatcher} dispatches '_ask', '_answer', and '_error' L{AmpBox}es,
both incoming and outgoing, to their appropriate destinations.
Outgoing commands are converted into L{Deferred}s and outgoing boxes, and
associated tracking state to fire those L{Deferred} when '_answer' boxes
come back. Incoming '_answer' and '_error' boxes are converted into
callbacks and errbacks on those L{Deferred}s, respectively.
Incoming '_ask' boxes are converted into method calls on a supplied method
locator.
@ivar _outstandingRequests: a dictionary mapping request IDs to
L{Deferred}s which were returned for those requests.
@ivar locator: an object with a L{locateResponder} method that locates a
responder function that takes a Box and returns a result (either a Box or a
Deferred which fires one).
@ivar boxSender: an object which can send boxes, via the L{_sendBox}
method, such as an L{AMP} instance.
@type boxSender: L{IBoxSender}
l c C s i | _ | | _ d S( N( t _outstandingRequestst locator( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c C s
| | _ d S( s
The given boxSender is going to start calling boxReceived on this
L{BoxDispatcher}.
@param boxSender: The L{IBoxSender} to send command responses to.
N( R0 ( RB R0 ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR1 s c C s | j | d S( s
No further boxes will be received here. Terminate all currently
oustanding command deferreds with the given reason.
N( t failAllOutgoing( RB R3 ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR4 s c C sI | | _ | j j } d | _ x! | D] \ } } | j | q( Wd S( s
Call the errback on all outstanding requests awaiting responses.
@param reason: the Failure instance to pass to those errbacks.
N( t _failAllReasonR Re RL t errback( RB R3 t ORRC R@ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
c C s | j d 7_ d | j f S( s
Generate protocol-local serial numbers for _ask keys.
@return: a string that has not yet been used on this connection.
i s %x( t _counter( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _nextTag s c C s| | j d k r t | j S| | t <| j } | rE | | t <n | j | j | rr t } | j | <n d } | S( s
Send a command across the wire with the given C{amp.Box}.
Mutate the given box to give it any additional keys (_command, _ask)
required for the command and request/response machinery, then send it.
If requiresAnswer is True, returns a C{Deferred} which fires when a
response is received. The C{Deferred} is fired with an C{amp.Box} on
success, or with an C{amp.RemoteAmpError} if an error is received.
If the Deferred fails and the error is not handled by the caller of
this method, the failure will be logged and the connection dropped.
@param command: a str, the name of the command to issue.
@param box: an AmpBox with the arguments for the command.
@param requiresAnswer: a boolean. Defaults to True. If True, return a
Deferred which will fire when the other side responds to this command.
If False, return None and do not ask the other side for acknowledgement.
@return: a Deferred which fires the AmpBox that holds the response to
this command, or None, as specified by requiresAnswer.
@raise ProtocolSwitched: if the protocol has been switched.
N(
R RL R t COMMANDR t ASKRv R0 R R ( RB t commandR+ t requiresAnswert tagt result( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _sendBoxCommand s
c K s t | } | j | | | S( so
This is a low-level API, designed only for optimizing simple messages
for which the overhead of parsing is too great.
@param command: a str naming the command.
@param kw: arguments to the amp box.
@param requiresAnswer: a boolean. Defaults to True. If True, return a
Deferred which will fire when the other side responds to this command.
If False, return None and do not ask the other side for acknowledgement.
@return: a Deferred which fires the AmpBox that holds the response to
this command, or None, as specified by requiresAnswer.
( t BoxR ( RB R R R R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt callRemoteString s c O s. y | | | } Wn t SX| j | S( sh
This is the primary high-level API for sending messages via AMP. Invoke it
with a command and appropriate arguments to send a message to this
connection's peer.
@param commandType: a subclass of Command.
@type commandType: L{type}
@param a: Positional (special) parameters taken by the command.
Positional parameters will typically not be sent over the wire. The
only command included with AMP which uses positional parameters is
L{ProtocolSwitchCommand}, which takes the protocol that will be
switched to as its first argument.
@param kw: Keyword arguments taken by the command. These are the
arguments declared in the command's 'arguments' attribute. They will
be encoded and sent to the peer as arguments for the L{commandType}.
@return: If L{commandType} has a C{requiresAnswer} attribute set to
L{False}, then return L{None}. Otherwise, return a L{Deferred} which
fires with a dictionary of objects representing the result of this
call. Additionally, this L{Deferred} may fail with an exception
representing a connection failure, with L{UnknownRemoteError} if the
other end of the connection fails for an unknown reason, or with any
error specified as a key in L{commandType}'s C{errors} dictionary.
( R t
_doCommand( RB t commandTypet aR t co( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt
callRemote s
%c C s | j j | S( sy
This is a terminal callback called after application code has had a
chance to quash any errors.
( R0 R. ( RB R- ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR. 8 s c C s7 | j j | t } | j | j | j | d S( s
An AMP box was received that answered a command previously sent with
L{callRemote}.
@param box: an AmpBox with a value for its L{ANSWER} key.
N( R t popt ANSWERt
addErrbackR. t callback( RB R+ t question( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _answerReceived@ s c C s | j j | t } | j | j | t } | t } | t k r\ t | | | } n t | | } | j t
| d S( s
An AMP box was received that answered a command previously sent with
L{callRemote}, with an error.
@param box: an L{AmpBox} with a value for its L{ERROR}, L{ERROR_CODE},
and L{ERROR_DESCRIPTION} keys.
N( R R t ERRORR R. t
ERROR_CODEt ERROR_DESCRIPTIONt PROTOCOL_ERRORSRR R R ( RB R+ R RU RV t exc( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _errorReceivedL s
c sp f d } f d } | j } t k r\ | j | | | j | j n | j | j d S( sc
@param box: an L{AmpBox} with a value for its L{COMMAND} and L{ASK}
keys.
c s t | t <| S( N( R R ( t answerBox( R+ ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt formatAnswerd s c s | j t rK | j j } | j j } | j j r? t } qm t } n" t } t j | t
} d } t | t <| | t
<| | t <| S( Ns
Unknown Error( t checkRR R@ RU RV RW Ry R` R t errR\ R R R R ( t errort codet desct errorBox( R+ ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt formatErrorg s
N( t dispatchCommandR t addCallbackst addCallbackt _safeEmitR R. ( RB R+ R R t deferred( ( R+ s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _commandReceived_ s c C sd t | k r | j | nD t | k r8 | j | n( t | k rT | j | n t | d S( s
An AmpBox was received, representing a command, or an answer to a
previously issued command (either successful or erroneous). Respond to
it according to its contents.
@param box: an AmpBox
@raise NoEmptyBoxes: when a box is received that does not contain an
'_answer', '_command' / '_ask', or '_error' key; i.e. one which does not
fit into the command / response protocol defined by AMP.
N( R R R R R R R: ( RB R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR2 s c C s2 y | j | j Wn t t f k
r- n Xd S( s
Emit a box, ignoring L{ProtocolSwitched} and L{ConnectionLost} errors
which cannot be usefully handled.
N( Rv R0 R8 R ( RB t aBox( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C sa | t } | j j | } | d k rT t t t d | f t d t t St
| | S( s
A box with a _command key was received.
Dispatch it to a local handler call it.
@param proto: an AMP instance.
@param box: an AmpBox to be dispatched.
s Unhandled Command: %rRE N( R R R6 RL R RR t UNHANDLED_ERROR_CODERZ R R^ R ( RB R+ t cmdt responder( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
N( R' R( R) R R/ RL R R R R0 R= R1 R4 R R Rl R R R R. R R R R2 R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s*
) , ! t CommandLocatorc B sI e Z d Z d e f d YZ e e d Z d Z d Z RS( s
A L{CommandLocator} is a collection of responders to AMP L{Command}s, with
the help of the L{Command.responder} decorator.
t
__metaclass__c B s e Z d Z g Z d Z RS( s
This metaclass keeps track of all of the Command.responder-decorated
methods defined since the last CommandLocator subclass was defined. It
assumes (usually correctly, but unfortunately not necessarily so) that
those commands responders were all declared as methods of the class
being defined. Note that this list can be incorrect if users use the
Command.responder decorator outside the context of a CommandLocator
class declaration.
Command responders defined on subclasses are given precedence over
those inherited from a base class.
The Command.responder decorator explicitly cooperates with this
metaclass.
c C s | j } g | j (i } | d <t j | | | | } t | j d } | j x' | D] } | j t | d i q^ Wx' | D] \ } }
| |
f | | j <q W| r | j t
j k r d } | | _ n | S( Nt _commandDispatchi c S s& t j d d t d d | j | S( Ns- Override locateResponder, not lookupFunction.t categoryt
stackleveli ( t warningst warnt PendingDeprecationWarningt lookupFunction( RB R! ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR6 s
( t _currentClassCommandsRh t __new__t listt __mro__t reverseRb t getattrt commandNameR R R6 ( t clsR! t basest attrst commandst cdt subclst ancestorst ancestort commandClasst
responderFuncR6 ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
( R' R( R) R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c s f d } | S( s<
Wrap aCallable with its command's argument de-serialization
and result serialization logic.
@param aCallable: a callable with a 'command' attribute, designed to be
called with keyword arguments.
@param command: the command class whose serialization to use.
@return: a 1-arg callable which, when invoked with an AmpBox, will
deserialize the argument list and invoke appropriate user code for the
callable's command, returning a Deferred which fires with the result or
fails with an error.
c sU j | } f d } f d } t | j | j | S( Nc sS | j j } j | } t | j } t t | | | j k d | S( NRE ( t trapt allErrorst strR@ R RR t fatalErrors( R RC R R ( R ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt checkKnownErrors s
c sG y j | SWn, t } t d | f | n Xd S( Ns, %r returned %r and %r could not serialize it( t makeResponseR RM ( R# t originalFailure( RB t aCallableR ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt makeResponseFor s ( t parseArgumentsR R R ( R+ R R R ( RB R R ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt doit s ( ( RB R R R ( ( R RB R s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _wrapWithSerialization s c C sK | j j t j k r% t j | | St j d d t d d | j | S( s;
Deprecated synonym for L{locateResponder}
s) Call locateResponder, not lookupFunction.R R i ( Ra R R R6 R R R ( RB R! ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C sQ | j } | | k rM | | \ } } t j | | | j } | j | | Sd S( s
Locate a callable to invoke when executing the named command.
@param name: the normalized name (from the wire) of the command.
@return: a 1-argument function that takes a Box and returns a box or a
Deferred which fires a Box, for handling the command identified by the
given name, or None, if no appropriate responder can be found.
N( R t typest
MethodTypeRa R ( RB R! R R R t responderMethod( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR6 s (
R' R( R) Rh R R R5 R R R6 ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s )
)
t SimpleStringLocatorc B s' e Z d Z e e d Z d Z RS( sZ
Implement the L{locateResponder} method to do simple, string-based
dispatch.
t amp_c C s# | j | j } t | | d S( sb
Locate a callable to invoke when executing the named command.
@return: a function with the name C{"amp_" + name} on L{self}, or None
if no such function exists. This function will then be called with the
L{AmpBox} itself as an argument.
@param name: the normalized name (from the wire) of the command.
N( t baseDispatchPrefixt upperR RL ( RB R! t fName( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR6 = s
( R' R( R) R R5 R R6 ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR 3 s
t andt delt fort ist raiset assertt elift fromt lambdat returnt breakt elset globalt nott tryt classt exceptt ift ort whilet continuet exect importt passt yieldt deft finallyt int printc C s, | j d d } | t k r( | j S| S( sU
(Private) Normalize an argument name from the wire for use with Python
code. If the return value is going to be a python keyword it will be
capitalized. If it contains any dashes they will be replaced with
underscores.
The rationale behind this method is that AMP should be an inherently
multi-language protocol, so message keys may contain all manner of bizarre
bytes. This is not a complete solution; there are still forms of arguments
that this implementation will be unable to parse. However, Python
identifiers share a huge raft of properties with identifiers from many
other languages, so this is a 'good enough' effort for now. We deal
explicitly with dashes because that is the most likely departure: Lisps
commonly use dashes to separate method names, so protocols initially
implemented in a lisp amp dialect may use dashes in argument or command
names.
@param key: a str, looking something like 'foo-bar-baz' or 'from'
@return: a str which is a valid python identifier, looking something like
'foo_bar_baz' or 'From'.
t -t _( t replacet PYTHON_KEYWORDSt title( RC t lkey( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _wireNameToPythonIdentifierT s
t Argumentc B si e Z d Z e e e Z e d Z d Z d Z d Z
d Z d Z d Z
d Z RS( s
Base-class of all objects that take values from Amp packets and convert
them into objects for Python functions.
This implementation of L{IArgumentType} provides several higher-level
hooks for subclasses to override. See L{toString} and L{fromString}
which will be used to define the behavior of L{IArgumentType.toBox} and
L{IArgumentType.fromBox}, respectively.
c C s
| | _ d S( s
Create an Argument.
@param optional: a boolean indicating whether this argument can be
omitted in the protocol.
N( t optional( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c C sD | j r1 | j | } | d k r@ | | =q@ n | j | } | S( s/
Retrieve the given key from the given dictionary, removing it if found.
@param d: a dictionary.
@param name: a key in L{d}.
@param proto: an instance of an AMP.
@raise KeyError: if I am not optional and no value was found.
@return: d[name].
N( R t getRL R ( RB t dR! R$ R@ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt retrieve s
c C s] | j | | | } t | } | j rC | d k rC d | | <n | j | | | | <d S( s%
Populate an 'out' dictionary with mapping names to Python values
decoded from an 'in' AmpBox mapping strings to string values.
@param name: the argument name to retrieve
@type name: str
@param strings: The AmpBox to read string(s) from, a mapping of
argument names to string values.
@type strings: AmpBox
@param objects: The dictionary to write object(s) to, a mapping of
names to Python objects.
@type objects: dict
@param proto: an AMP instance.
N( R R R RL t fromStringProto( RB R! R" R# R$ t stt nk( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR% s
c C sM | j | t | | } | j r3 | d k r3 n | j | | | | <d S( s9
Populate an 'out' AmpBox with strings encoded from an 'in' dictionary
mapping names to Python values.
@param name: the argument name to retrieve
@type name: str
@param strings: The AmpBox to write string(s) to, a mapping of
argument names to string values.
@type strings: AmpBox
@param objects: The dictionary to read object(s) from, a mapping of
names to Python objects.
@type objects: dict
@param proto: the protocol we are converting for.
@type proto: AMP
N( R R R RL t
toStringProto( RB R! R" R# R$ t obj( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR& s c C s
| j | S( s
Convert a string to a Python value.
@param inString: the string to convert.
@param proto: the protocol we are converting for.
@type proto: AMP
@return: a Python object.
( t
fromString( RB t inStringR$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C s
| j | S( s
Convert a Python object to a string.
@param inObject: the object to convert.
@param proto: the protocol we are converting for.
@type proto: AMP
( t toString( RB t inObjectR$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C s d S( s
Convert a string to a Python object. Subclasses must implement this.
@param inString: the string to convert.
@type inString: str
@return: the decoded value from inString
N( ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C s d S( s
Convert a Python object into a string for passing over the network.
@param inObject: an object of the type that this Argument is intended
to deal with.
@return: the wire encoding of inObject
@rtype: str
N( ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s ( R' R( R) R R RZ R R= R R% R& R R R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR
r s
t Integerc B s e Z d Z e Z d Z RS( s
Encode any integer values of any size on the wire as the string
representation.
Example: C{123} becomes C{"123"}
c C s t t | S( N( R t int( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s ( R' R( R) R R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR
s t Stringc B s e Z d Z d Z d Z RS( sB
Don't do any conversion at all; just pass through 'str'.
c C s | S( N( ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C s | S( N( ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s ( R' R( R) R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s t Floatc B s e Z d Z e Z e Z RS( sA
Encode floating-point values on the wire as their repr.
( R' R( R) t floatR RG R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR $ s t Booleanc B s e Z d Z d Z d Z RS( s@
Encode True or False as "True" or "False" on the wire.
c C s7 | d k r t S| d k r t St d | f d S( NRl RZ s Bad boolean value: %r( Rl RZ Rj ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR 1 s
c C s | r
d Sd Sd S( NRl RZ ( ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR : s ( R' R( R) R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR - s t Unicodec B s e Z d Z d Z d Z RS( s7
Encode a unicode string on the wire as UTF-8.
c C s t j | | j d S( Ns utf-8( R R t encode( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR G s c C s t j | | j d S( Ns utf-8( R R t decode( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR L s ( R' R( R) R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR B s t Pathc B s e Z d Z d Z d Z RS( sY
Encode and decode L{filepath.FilePath} instances as paths on the wire.
This is really intended for use with subprocess communication tools:
exchanging pathnames on different machines over a network is not generally
meaningful, but neither is it disallowed; you can use this to communicate
about NFS paths, for example.
c C s t j t j | | S( N( R t FilePathR R ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR [ s c C s t j | | j S( N( R R t path( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR _ s ( R' R( R) R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR! R s t ListOfc B s, e Z d Z e d Z d Z d Z RS( s
Encode and decode lists of instances of a single other argument type.
For example, if you want to pass::
[3, 7, 9, 15]
You can create an argument like this::
ListOf(Integer())
The serialized form of the entire list is subject to the limit imposed by
L{MAX_VALUE_LENGTH}. List elements are represented as 16-bit length
prefixed strings. The argument type passed to the L{ListOf} initializer is
responsible for producing the serialized form of each element.
@ivar elementType: The L{Argument} instance used to encode and decode list
elements (note, not an arbitrary L{IArgument} implementation:
arguments must be implemented using only the C{fromString} and
C{toString} methods, not the C{fromBox} and C{toBox} methods).
@param optional: a boolean indicating whether this argument can be
omitted in the protocol.
@since: 10.0
c C s | | _ t j | | d S( N( t elementTypeR
R= ( RB R% R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c C s; g } t } | j | _ | j | t | j j | S( sn
Convert the serialized form of a list of instances of some type back
into that list.
( R Rg t stringReceivedt dataReceivedt mapR% R ( RB R R" t parser( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
c C s_ g } xI | D]A } | j j | } | j t d t | | j | q
Wd j | S( sI
Serialize the given list of objects to a single string.
s !HRS ( R% R Rg R RH Rn ( RB R R" R t
serialized( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
( R' R( R) RZ R= R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR$ d s t AmpListc B s, e Z d Z e d Z d Z d Z RS( sI
Convert a list of dictionaries into a list of AMP boxes on the wire.
For example, if you want to pass::
[{'a': 7, 'b': u'hello'}, {'a': 9, 'b': u'goodbye'}]
You might use an AmpList like this in your arguments or response list::
AmpList([('a', Integer()),
('b', Unicode())])
c C s | | _ t j | | d S( s#
Create an AmpList.
@param subargs: a list of 2-tuples of ('name', argument) describing the
schema of the dictionaries in the sequence of amp boxes.
@param optional: a boolean indicating whether this argument can be
omitted in the protocol.
N( t subargsR
R= ( RB R, R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s
c C s8 t | } g | D] } t | | j | ^ q } | S( N( t parseStringt _stringsToObjectsR, ( RB R R$ t boxesR+ t values( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s %c C s; d j g | D]' } t | | j t | j ^ q
S( NRS ( Rn t _objectsToStringsR, R Ru ( RB R R$ R# ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s ( R' R( R) RZ R= R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR+ s t Commandc B s e Z d Z d e f d YZ g Z g Z g Z i Z i Z e
Z e
Z e
Z d Z d Z e e Z d Z e e Z d Z e e Z d Z e e Z d Z e e Z d Z RS(
s
Subclass me to specify an AMP Command.
@cvar arguments: A list of 2-tuples of (name, Argument-subclass-instance),
specifying the names and values of the parameters which are required for
this command.
@cvar response: A list like L{arguments}, but instead used for the return
value.
@cvar errors: A mapping of subclasses of L{Exception} to wire-protocol tags
for errors represented as L{str}s. Responders which raise keys from this
dictionary will have the error translated to the corresponding tag on the
wire. Invokers which receive Deferreds from invoking this command with
L{AMP.callRemote} will potentially receive Failures with keys from this
mapping as their value. This mapping is inherited; if you declare a
command which handles C{FooError} as 'FOO_ERROR', then subclass it and
specify C{BarError} as 'BAR_ERROR', responders to the subclass may raise
either C{FooError} or C{BarError}, and invokers must be able to deal with
either of those exceptions.
@cvar fatalErrors: like 'errors', but errors in this list will always
terminate the connection, despite being of a recognizable error type.
@cvar commandType: The type of Box used to issue commands; useful only for
protocol-modifying behavior like startTLS or protocol switching. Defaults
to a plain vanilla L{Box}.
@cvar responseType: The type of Box used to respond to this command; only
useful for protocol-modifying behavior like startTLS or protocol switching.
Defaults to a plain vanilla L{Box}.
@ivar requiresAnswer: a boolean; defaults to True. Set it to False on your
subclass if you want callRemote to return None. Note: this is a hint only
to the client side of the protocol. The return-type of a command responder
method must always be a dictionary adhering to the contract specified by
L{response}, because clients are always free to request a response if they
want one.
R c B s e Z d Z d Z RS( st
Metaclass hack to establish reverse-mappings for 'errors' and
'fatalErrors' as class vars.
c C s i } | d <i } | d <d | k r5 | | d <n t j | | | | } i } i } t | d | t | d | x. | j D] \ } }
| | |
<|
| | <q Wx. | j D] \ } }
| | |
<|
| | <q W| S( Nt
reverseErrorsR R t errorsR ( Rh R R t iteritems( R R! R R R3 t ert newtypeR4 R Rs Rr ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
( R' R( R) R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c K s | | _ | j } g } xI | j D]> \ } } t | } | | k r% | j r% | j | q% q% W| r t d d j | | j f n g } d S( s4
Create an instance of this command with specified values for its
parameters.
@param kw: a dict containing an appropriate value for each name
specified in the L{arguments} attribute of my class.
@raise InvalidSignature: if you forgot any required arguments.
s forgot %s for %ss , N( t
structuredt keyst argumentsR R Rg R; Rn R ( RB R t givenArgst forgottenR! t argt
pythonName( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s
c C s4 y | j } Wn t SXt | | j | | S( s`
Serialize a mapping of arguments using this L{Command}'s
response schema.
@param objects: a dict with keys matching the names specified in
self.response, having values of the types that the Argument objects in
self.response can format.
@param proto: an L{AMP}.
@return: an L{AmpBox}.
( t responseTypeR R1 t response( R R# R$ R? ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR ' s
c C s t } x* | j D] \ } } | j t | q Wx0 | D]( } | | k r= t d | f q= q= Wt | | j | j | S( s
Serialize a mapping of arguments using this L{Command}'s
argument schema.
@param objects: a dict with keys similar to the names specified in
self.arguments, having values of the types that the Argument objects in
self.arguments can parse.
@param proto: an L{AMP}.
@return: An instance of this L{Command}'s C{commandType}.
s %s is not a valid argument( R R: t addR R; R1 R ( R R# R$ t allowedNamest argNamet ignoredt intendedArg( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt
makeArguments< s
c C s t | | j | S( sZ
Parse a mapping of serialized arguments using this
L{Command}'s response schema.
@param box: A mapping of response-argument names to the
serialized forms of those arguments.
@param protocol: The L{AMP} protocol.
@return: A mapping of response-argument names to the parsed
forms.
( R. R@ ( R R+ t protocol( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt
parseResponseV s c C s t | | j | S( s?
Parse a mapping of serialized arguments using this
L{Command}'s argument schema.
@param box: A mapping of argument names to the seralized forms
of those arguments.
@param protocol: The L{AMP} protocol.
@return: A mapping of argument names to the parsed forms.
( R. R: ( R R+ RG ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR f s c C s t j j | | f | S( s
Declare a method to be a responder for a particular command.
This is a decorator.
Use like so::
class MyCommand(Command):
arguments = [('a', ...), ('b', ...)]
class MyProto(AMP):
def myFunMethod(self, a, b):
...
MyCommand.responder(myFunMethod)
Notes: Although decorator syntax is not used within Twisted, this
function returns its argument and is therefore safe to use with
decorator syntax.
This is not thread safe. Don't declare AMP subclasses in other
threads. Don't declare responders outside the scope of AMP subclasses;
the behavior is undefined.
@param methodfunc: A function which will later become a method, which
has a keyword signature compatible with this command's L{argument} list
and returns a dictionary with a set of keys compatible with this
command's L{response} list.
@return: the methodfunc parameter.
( R R Rg ( R t
methodfunc( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR u s c si f d } | j j j j | j } j re | j j | | j | n | S( sL
Encode and send this Command to the given protocol.
@param proto: an AMP, representing the connection to send to.
@return: a Deferred which will fire or error appropriately when the
other side responds to the command (or error if the connection is lost
before it is responded to).
c sA | j t | j } j j | j t } t | | j S( N( R RR R@ R3 R RU R[ R RV ( R t rjet errorType( RB ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt
_massageError s
( R R RF R8 R R RH R ( RB R$ RL R
( ( RB s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s ( R' R( R) Rh R R: R@ t extraR4 R R R R? Rl R R= R t classmethodRF RH R R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR2 s, '
! t _NoCertificatec B s e Z d Z d Z d Z RS( s
This is for peers which don't want to use a local certificate. Used by
AMP because AMP's internal language is all about certificates and this
duck-types in the appropriate place; this API isn't really stable though,
so it's not exposed anywhere public.
For clients, it will use ephemeral DH keys, or whatever the default is for
certificate-less clients in OpenSSL. For servers, it will generate a
temporary self-signed certificate with garbage values in the DN and use
that.
c C s
| | _ d S( sT
Create a _NoCertificate which either is or isn't for the client side of
the connection.
@param client: True if we are a client and should truly have no
certificate and be anonymous, False if we are a server and actually
have to generate a temporary certificate.
@type client: bool
N( t client( RB RP ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c
G s | j sj t d d } t j } | j | } | j | | d d } | j | } | j | St } | r | j t d t
d t
d g | D] } | j ^ q n t | } | S( sT
Behaves like L{twisted.internet.ssl.PrivateCertificate.options}().
t CNs TEMPORARY CERTIFICATEc S s t S( N( Rl ( t dn( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt <lambda> s i t verifyt requireCertificatet caCerts(
RP R R t generatet certificateRequestt signCertificateRequestt newCertificatet optionsRw Rb Rl t originalR (
RB t authoritiest sharedDNRC t crt sscrdt certR[ t autht occo( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR[ s
# ( R' R( R) R= R[ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRO s t _TLSBoxc B sS e Z d Z g Z d Z d Z e d e e Z e d d Z
d Z RS( sK
I am an AmpBox that, upon being sent, initiates a TLS connection.
c C s/ t d k r t d d n t j | d S( Nt TLS_ERRORs TLS not available( R RL RR R` R= ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c s t f d S( Nc s | j S( N( R ( RB ( t defaultRr ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRS s ( t property( Rr Rf ( ( Rf Rr s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _keyprop s t tls_localCertificatet tls_verifyAuthoritiesc C sZ t | } x$ d d g D] } | j | d q W| j | | j | j | j d S( sK
Send my encoded value to the protocol, then initiate TLS.
Ri Rj N( R` R RL Rv t _startTLSt certificateRT ( RB R$ t abRr ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRv s
N( R' R( R) Rx R= Rh RO RZ Rl RL RT Rv ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRd s t _LocalArgumentc B s e Z d Z d Z RS( s
Local arguments are never actually relayed across the wire. This is just a
shim so that StartTLS can pretend to have some arguments: if arguments
acquire documentation properties, replace this with something nicer later.
c C s d S( N( ( RB R! R" R# R$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR% s ( R' R( R) R% ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRn s t StartTLSc B sz e Z d Z d e d e f d e d e f g Z d e d e f d e d e f g Z e Z d Z d Z
RS( sz
Use, or subclass, me to implement a command that starts TLS.
Callers of StartTLS may pass several special arguments, which affect the
TLS negotiation:
- tls_localCertificate: This is a
twisted.internet.ssl.PrivateCertificate which will be used to secure
the side of the connection it is returned on.
- tls_verifyAuthorities: This is a list of
twisted.internet.ssl.Certificate objects that will be used as the
certificate authorities to verify our peer's certificate.
Each of those special parameters may also be present as a key in the
response dictionary.
Ri R Rj c K s_ t d k r t d n | j d t t | _ | j d d | _ t j | | d S( s
Create a StartTLS command. (This is private. Use AMP.callRemote.)
@param tls_localCertificate: the PrivateCertificate object to use to
secure the connection. If it's None, or unspecified, an ephemeral DH
key is used instead.
@param tls_verifyAuthorities: a list of Certificate objects which
represent root certificates to verify our peer with.
s TLS not available.Ri Rj N(
R RL t RuntimeErrorR RO Rl Rl R] R2 R= ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= 6 s
c sK t j } j j j f d } | j | | S( s
When a StartTLS command is sent, prepare to start TLS, but don't actually
do it; wait for the acknowledgement, then initiate the TLS handshake.
c s j j j | S( N( Rk Rl R] ( R@ ( RB R$ ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt
actuallystartP s ( R2 R t _prepareTLSRl R] R ( RB R$ R
Rq ( ( RB R$ s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR H s
( R' R( R) Rn Rl R: R@ Rd R? R= R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRo s t ProtocolSwitchCommandc B s5 e Z d Z d Z d Z e e Z d Z RS( s
Use this command to switch from something Amp-derived to a different
protocol mid-connection. This can be useful to use amp as the
connection-startup negotiation phase. Since TLS is a different layer
entirely, you can use Amp to negotiate the security parameters of your
connection, then switch to a different protocol, and the connection will
remain secured.
c K s# | | _ t t | j | d S( s
Create a ProtocolSwitchCommand.
@param _protoToSwitchToFactory: a ProtocolFactory which will generate
the Protocol to switch to.
@param kw: Keyword arguments, encoded and handled normally as
L{Command} would.
N( t protoToSwitchToFactoryRz Rs R= ( RB t _protoToSwitchToFactoryR ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= b s c C s
t | S( N( R} ( R R~ R$ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR q s c sV t t j } j f d } f d } | j | | S( s
When we emit a ProtocolSwitchCommand, lock the protocol, but don't actually
switch to the new protocol unless an acknowledgement is received. If
an error is received, switch back.
c s2 j j j j } j | j | S( N( Rt t
buildProtocolR{ t getPeerR ( t ignR~ ( RB R$ ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt switchNow~ s c s' j j j d t t | S( N( t _unlockFromSwitchRt t clientConnectionFailedRL R R
( Rx ( R$ RB ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt handle s
( Rz Rs R R R ( RB R$ R
Ry R| ( ( R$ RB s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR v s
( R' R( R) R= R RN R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRs X s
t BinaryBoxProtocolc B s e Z d Z e e e Z d Z e Z d Z
d Z e Z d Z
e Z d Z d Z d Z d d Z d Z d Z d Z d Z d Z d Z e Z d Z d
Z d Z d Z d
Z d Z d Z d Z! d Z" e# e" Z$ d Z% d Z& e' j( e& RS( s
A protocol for receving L{Box}es - key/value pairs - via length-prefixed
strings. A box is composed of:
- any number of key-value pairs, described by:
- a 2-byte network-endian packed key length (of which the first
byte must be null, and the second must be non-null: i.e. the
value of the length must be 1-255)
- a key, comprised of that many bytes
- a 2-byte network-endian unsigned value length (up to the maximum
of 65535)
- a value, comprised of that many bytes
- 2 null bytes
In other words, an even number of strings prefixed with packed unsigned
16-bit integers, and then a 0-length string to indicate the end of the box.
This protocol also implements 2 extra private bits of functionality related
to the byte boundaries between messages; it can start TLS between two given
boxes or switch to an entirely different protocol. However, due to some
tricky elements of the implementation, the public interface to this
functionality is L{ProtocolSwitchCommand} and L{StartTLS}.
@ivar _keyLengthLimitExceeded: A flag which is only true when the
connection is being closed because a key length prefix which was longer
than allowed by the protocol was received.
@ivar boxReceiver: an L{IBoxReceiver} provider, whose L{ampBoxReceived}
method will be invoked for each L{Box} that is received.
c C s
| | _ d S( N( t boxReceiver( RB R~ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c C sN | j } d | _ | | _ | | _ | j | j | rJ | j | n d S( s
Switch this BinaryBoxProtocol's transport to a new protocol. You need
to do this 'simultaneously' on both ends of a connection; the easiest
way to do this is to use a subclass of ProtocolSwitchCommand.
@param newProto: the new protocol instance to switch to.
@param clientFactory: the ClientFactory to send the
L{clientConnectionLost} notification to.
RS N( t recvdt
innerProtocolt innerProtocolClientFactoryt makeConnectionR{ R' ( RB t newProtot
clientFactoryt newProtoData( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C so | j r t d n | j d k r3 t n | j d k rU | j j | n | j j | j d S( s/
Send a amp.Box to my peer.
Note: transport.write is never called outside of this method.
@param box: an AmpBox.
@raise ProtocolSwitched: if the protocol has previously been switched.
@raise ConnectionLost: if the connection has previously been lost.
s5 This connection has switched: no AMP traffic allowed.N( t _lockedR8 R{ RL R t _startingTLSBufferRg t writeRu ( RB R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR, s c C s' | | _ | j j | | j d S( s
Notify L{boxReceiver} that it is about to receive boxes from this
protocol by invoking L{startReceivingBoxes}.
N( R{ R~ R1 t connectionMade( RB R{ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C sH | j r t | _ n | j d k r8 | j j | d St j | | S( sg
Either parse incoming data as L{AmpBox}es or relay it to our nested
protocol.
N( t _justStartedTLSRZ R RL R' R ( RB t data( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR' s c C s | j d k rG | j j | | j d k rG | j j d | qG n | j rn t t t t d d } n- | j
t r | j r t
d } n | } | j j | d S( sF
The connection was lost; notify any nested protocol.
s4 Peer rejected our certificate for an unknown reason.N( R RL t connectionLostR t clientConnectionLostt _keyLengthLimitExceededR R< Rl RZ R R
R R R~ R4 ( RB R3 t
failReason( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s i i c C s t | _ | j | S( s6
String received in the 'init' state.
( R` t _currentBoxt proto_key( RB t string( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt
proto_init, s c C sC | r | | _ | j | _ d S| j j | j d | _ d Sd S( su
String received in the 'key' state. If the key is empty, a complete
box has been received.
R@ t initN( t _currentKeyt _MAX_VALUE_LENGTHt
MAX_LENGTHR~ R2 R RL ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR 4 s c C s) | | j | j <d | _ | j | _ d S( s7
String received in the 'value' state.
RC N( R R RL t _MAX_KEY_LENGTHR ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt proto_valueC s c C s t | _ | j j d S( s
The key length limit was exceeded. Disconnect the transport and make
sure a meaningful exception is reported.
N( Rl R R{ R| ( RB t length( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt lengthLimitExceededM s c C s
t | _ d S( s
Lock this binary protocol so that no further boxes may be sent. This
is used when sending a request to switch underlying protocols. You
probably want to subclass ProtocolSwitchCommand rather than calling
this directly.
N( Rl R ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR V s c C s+ | j d k r t d n t | _ d S( s
Unlock this locked binary protocol so that further boxes may be sent
again. This is used after an attempt to switch protocols has failed
for some reason.
s* Protocol already switched. Cannot unlock.N( R RL R8 RZ R ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRz ` s c C sD g | _ | j d k r@ t d | j | j | | f f n d S( s
Used by StartTLSCommand to put us into the state where we don't
actually send things that get sent, instead we buffer them. see
L{_sendBox}.
sU Previously authenticated connection between %s and %s is trying to re-establish as %sN( R t hostCertificateRL R9 t peerCertificate( RB Rl t verifyAuthorities( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRr k s c C s | | _ t | _ | d k r' d } n | j j | j | | j } | d k r d | _ x | D] } | j | qe Wn d S( s<
Used by TLSBox to initiate the SSL handshake.
@param certificate: a L{twisted.internet.ssl.PrivateCertificate} for
use locally.
@param verifyAuthorities: L{twisted.internet.ssl.Certificate} instances
representing certificate authorities which will verify our peer.
N( ( R Rl R RL R{ t startTLSR[ R R, ( RB Rl R t stlsbR+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRk { s
c C s | j r
d St j | j S( N( t noPeerCertificateRL R t peerFromTransportR{ ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _getPeerCertificate s c C s3 t j | d | j d k r/ | j j n d S( sv
The buck stops here. This error was completely unhandled, time to
terminate the connection.
s Amp server or network failure unhandled by client application. Dropping connection! To avoid, add errbacks to ALL remote commands!N( R R R{ RL R| ( RB R- ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR. s
c C s i S( sX
The default TLS responder doesn't specify any certificate or anything.
From a security perspective, it's little better than a plain-text
connection - but it is still a *bit* better, so it's included for
convenience.
You probably want to override this by providing your own StartTLS.responder.
( ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt _defaultStartTLSResponder s
N() R' R( R) R R* RZ R RL R R R R R R R R R R= R R, R R' R R R R R R R R R Rz Rr Rk R Rg R R. R Ro R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR} sD
t AMPc B sG e Z d Z e Z d d d Z d Z d Z d Z d Z
RS( sa
This protocol is an AMP connection. See the module docstring for protocol
details.
c C sW t | _ | d k r | } n | d k r3 | } n t j | | t j | | d S( N( Rl t _ampInitializedRL R R= R} ( RB R~ R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c C s8 t j | | } | d k r" | St j | | } | S( s
Unify the implementations of L{CommandLocator} and
L{SimpleStringLocator} to perform both kinds of dispatch, preferring
L{CommandLocator}.
N( R R6 RL R ( RB R! t firstRespondert secondResponder( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR6 s
c C sE | j d k r" d | j f } n d } d | j j | t | f S( so
A verbose string representation which gives us information about this
AMP connection.
s inner %rRS s <%s%s at 0x%x>N( R RL Ra R' R ( RB t innerRepr( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRK s
c C sq | j s t j | n | j | _ | j | _ t j d | j j
| j | j f t j | | d S( sI
Emit a helpful log message when the connection is made.
s+ %s connection established (HOST:%s PEER:%s)N(
R R R= Rw t _transportPeert getHostt _transportHostR t msgRa R' R} R ( RB R{ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C sC t j d | j j | j | j f t j | | d | _ d S( sI
Emit a helpful log message when the connection is lost.
s$ %s connection lost (HOST:%s PEER:%s)N(
R R Ra R' R R R} R RL R{ ( RB R3 ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s N( R' R( R) RZ R RL R= R6 RK R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
t
_ParserHelperc B sk e Z d Z d Z d Z d Z e Z d Z d Z d Z
e e
Z
d Z e e Z RS( s:
A box receiver which records all boxes received.
c C s
g | _ d S( N( R/ ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= s c C s d S( NR ( ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyRw s c C s d S( NR ( ( RB ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s c C s d S( s0
No initialization is required.
N( ( RB t sender( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR1 s c C s | j j | d S( N( R/ Rg ( RB R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR2 s c C s? | } t d | } | j | | j | j | j S( s
Parse some amp data stored in a file.
@param fileObj: a file-like object.
@return: a list of AmpBoxes encoded in the given file.
R~ ( R} R R' t readR/ ( R t fileObjt parserHelpert bbp( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt parse$ s
c C s | j t | S( s
Parse some amp data stored in a string.
@param data: a str holding some amp-encoded data.
@return: a list of AmpBoxes encoded in the given string.
( R R ( R R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR- 4 s (
R' R( R) R= Rw R RZ t
disconnectingR1 R2 R RN R- ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
c C sC i } | j } x* | D]" \ } } | j | | | | q W| S( s~
Convert an AmpBox to a dictionary of python objects, converting through a
given arglist.
@param strings: an AmpBox (or dict of strings)
@param arglist: a list of 2-tuples of strings and Argument objects, as
described in L{Command.arguments}.
@param proto: an L{AMP} instance.
@return: the converted dictionary mapping names to argument objects.
( Rd R% ( R" t arglistR$ R# t myStringst argnamet argparser( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR. D s
c C s= | j } x* | D]" \ } } | j | | | | q W| S( s-
Convert a dictionary of python objects to an AmpBox, converting through a
given arglist.
@param objects: a dict mapping names to python objects
@param arglist: a list of 2-tuples of strings and Argument objects, as
described in L{Command.arguments}.
@param strings: [OUT PARAMETER] An object providing the L{dict}
interface which will be populated with serialized data.
@param proto: an L{AMP} instance.
@return: The converted dictionary mapping names to encoded argument
strings (identical to C{strings}).
( Rd R& ( R# R R" R$ t myObjectsR R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR1 Z s t _FixedOffsetTZInfoc B s2 e Z d Z d Z d Z d Z d Z RS( s3
Represents a fixed timezone offset (without daylight saving time).
@ivar name: A C{str} giving the name of this timezone; the name just
includes how much time this offset represents.
@ivar offset: A C{datetime.timedelta} giving the amount of time this
timezone is offset.
c C st d | | | f | _ | d k r3 | } | } n" | d k rU t d | f n t j d | d | | _ d S( Ns %s%02i:%02iR t +s invalid sign for timezone %rt hourst minutes( R! t
ValueErrort datetimet timedeltat offset( RB t signR R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR= ~ s
c C s | j S( s9
Return this timezone's offset from UTC.
( R ( RB t dt( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt utcoffset s c C s
t j d S( s|
Return a zero C{datetime.timedelta} for the daylight saving time offset,
since there is never one.
i ( R R ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt dst s c C s | j S( s;
Return a string describing this timezone.
( R! ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt tzname s ( R' R( R) R= R R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s s
R i t Decimalc B s e Z d Z e j Z d Z RS( s
Encodes C{decimal.Decimal} instances.
There are several ways in which a decimal value might be encoded.
Special values are encoded as special strings::
- Positive infinity is encoded as C{"Infinity"}
- Negative infinity is encoded as C{"-Infinity"}
- Quiet not-a-number is encoded as either C{"NaN"} or C{"-NaN"}
- Signalling not-a-number is encoded as either C{"sNaN"} or C{"-sNaN"}
Normal values are encoded using the base ten string representation, using
engineering notation to indicate magnitude without precision, and "normal"
digits to indicate precision. For example::
- C{"1"} represents the value I{1} with precision to one place.
- C{"-1"} represents the value I{-1} with precision to one place.
- C{"1.0"} represents the value I{1} with precision to two places.
- C{"10"} represents the value I{10} with precision to two places.
- C{"1E+2"} represents the value I{10} with precision to one place.
- C{"1E-1"} represents the value I{0.1} with precision to one place.
- C{"1.5E+2"} represents the value I{15} with precision to two places.
U{http://speleotrove.com/decimal/} should be considered the authoritative
specification for the format.
c C s, t | t j r t | St d d S( sW
Serialize a C{decimal.Decimal} instance to the specified wire format.
s8 amp.Decimal can only encode instances of decimal.DecimalN( t
isinstancet decimalR R R ( RB R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s
( R' R( R) R R R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s t DateTimec B s e Z d Z e d d e d d e d d e d d e d d
e d d e d
d e d d e d d g Z d Z d Z RS( sO
Encodes C{datetime.datetime} instances.
Wire format: '%04i-%02i-%02iT%02i:%02i:%02i.%06i%s%02i:%02i'. Fields in
order are: year, month, day, hour, minute, second, microsecond, timezone
direction (+ or -), timezone hour, timezone minute. Encoded string is
always exactly 32 characters long. This format is compatible with ISO 8601,
but that does not mean all ISO 8601 dates can be accepted.
Also, note that the datetime module's notion of a "timezone" can be
complex, but the wire format includes only a fixed offset, so the
conversion is not lossless. A lossless transmission of a C{datetime} instance
is not feasible since the receiving end would require a Python interpreter.
@ivar _positions: A sequence of slices giving the positions of various
interesting parts of the wire format.
i i i i i i
i i
i i i i i i i i i i c C s t | d k r( t d | f n g | j D] } t | | ^ q2 } | d } t | | d } | g | d )t j | S( s|
Parse a string containing a date and time in the wire format into a
C{datetime.datetime} instance.
i s invalid date format %ri i ( RH R t
_positionsR R R ( RB t st pR0 R t timezone( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s &
c C s | j } | d k r' t d n | j d | j d } | d k rT d } n d } d | j | j | j | j | j | j
| j | t | d t | d f
S( sm
Serialize a C{datetime.datetime} instance to a string in the specified
wire format.
sU amp.DateTime cannot serialize naive datetime instances. You may find amp.utc useful.iQ i< i R R s- %04i-%02i-%02iT%02i:%02i:%02i.%06i%s%02i:%02iN(
R RL R t dayst secondst yeart montht dayt hourt minutet secondt microsecondt abs( RB Ro R t
minutesOffsetR ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s&
( R' R( R) t sliceR R R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyR s $$ (r R) Rh R R R t cStringIOR t structR R R t zope.interfaceR R t twisted.python.compatR t twisted.python.utilR t twisted.python.reflectR t twisted.python.failureR t twisted.pythonR R t twisted.internet.mainR
t twisted.internet.errorR R R
t twisted.internet.deferR R R t twisted.protocols.basicR R t twisted.internetR t ImportErrorRL t supportedt twisted.internet.sslR R R R R R R R R R R\ R Rk Rm R R* R/ R5 RT R7 R8 R9 R: R; R< RM RR R[ R] R^ R_ R Rw R` R Ry R} R R t objectR R R R
R R R R R R! R$ R+ R2 RO Rd Rn Ro Rs R} R R R R- R. R1 t tzinfoR t utcR R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/amp.pyt <module> s
%A "!
B# 6}
9'6! =4 * Q: ,*