Python: module gdata.tlslite.integration.TLSTwistedProtocolWrapper

gdata.tlslite.integration.TLSTwistedProtocolWrapper | index /usr/local/google/home/afshar/src/external-gdata-release/google3/src/gdata/tlslite/integration/TLSTwistedProtocolWrapper.py

`TLS Lite + Twisted.`

Modules
`` |  |
errno | socket |  |

Classes
`` |  | gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine TLSTwistedProtocolWrapper(twisted.protocols.policies.ProtocolWrapper, gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine) twisted.protocols.policies.ProtocolWrapper(twisted.internet.protocol.Protocol) TLSTwistedProtocolWrapper(twisted.protocols.policies.ProtocolWrapper, gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine)
class TLSTwistedProtocolWrapper(twisted.protocols.policies.ProtocolWrapper, gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine)
`` | `This class can wrap Twisted protocols to add TLS support. Below is a complete example of using TLS Lite with a Twisted echo server. There are two server implementations below. Echo is the original protocol, which is oblivious to TLS. Echo1 subclasses Echo and negotiates TLS when the client connects. Echo2 subclasses Echo and negotiates TLS when the client sends "STARTTLS":: from twisted.internet.protocol import Protocol, Factory from twisted.internet import reactor from twisted.protocols.policies import WrappingFactory from twisted.protocols.basic import LineReceiver from twisted.python import log from twisted.python.failure import Failure import sys from tlslite.api import * s = open("./serverX509Cert.pem").read() x509 = X509() x509.parse(s) certChain = X509CertChain([x509]) s = open("./serverX509Key.pem").read() privateKey = parsePEMKey(s, private=True) verifierDB = VerifierDB("verifierDB") verifierDB.open() class Echo(LineReceiver): def connectionMade(self): self.transport.write("Welcome to the echo server!\r\n") def lineReceived(self, line): self.transport.write(line + "\r\n") class Echo1(Echo): def connectionMade(self): if not self.transport.tlsStarted: self.transport.setServerHandshakeOp(certChain=certChain, privateKey=privateKey, verifierDB=verifierDB) else: Echo.connectionMade(self) def connectionLost(self, reason): pass #Handle any TLS exceptions here class Echo2(Echo): def lineReceived(self, data): if data == "STARTTLS": self.transport.setServerHandshakeOp(certChain=certChain, privateKey=privateKey, verifierDB=verifierDB) else: Echo.lineReceived(self, data) def connectionLost(self, reason): pass #Handle any TLS exceptions here factory = Factory() factory.protocol = Echo1 #factory.protocol = Echo2 wrappingFactory = WrappingFactory(factory) wrappingFactory.protocol = TLSTwistedProtocolWrapper log.startLogging(sys.stdout) reactor.listenTCP(1079, wrappingFactory) reactor.run() This class works as follows: Data comes in and is given to the AsyncStateMachine for handling. AsyncStateMachine will forward events to this class, and we'll pass them on to the ProtocolHandler, which will proxy them to the wrapped protocol. The wrapped protocol may then call back into this class, and these calls will be proxied into the AsyncStateMachine. The call graph looks like this: - self.dataReceived - AsyncStateMachine.inReadEvent - out(Connect|Close|Read)Event - ProtocolWrapper.(connectionMade|loseConnection|dataReceived) - self.(loseConnection|write|writeSequence) - AsyncStateMachine.(setCloseOp|setWriteOp)`
| Method resolution order: TLSTwistedProtocolWrapper twisted.protocols.policies.ProtocolWrapper twisted.internet.protocol.Protocol twisted.internet.protocol.BaseProtocol gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine Methods defined here: __init__(self, factory, wrappedProtocol) connectionLost(self, reason) connectionMade(self) dataReceived(self, data) loseConnection(self) outCloseEvent(self) outConnectEvent(self) outReadEvent(self, data) setServerHandshakeOp(self, **args) write(self, data) writeSequence(self, seq) Methods inherited from twisted.protocols.policies.ProtocolWrapper: __getattr__(self, name) getHost(self) getPeer(self) logPrefix(self) `Use a customized log prefix mentioning both the wrapped protocol and the current one.` makeConnection(self, transport) `When a connection is made, register this wrapper with its factory, save the real transport, and connect the wrapped protocol to this L{ProtocolWrapper} to intercept any transport calls it makes.` registerProducer(self, producer, streaming) stopConsuming(self) unregisterProducer(self) Data and other attributes inherited from twisted.protocols.policies.ProtocolWrapper: disconnecting = 0 Methods inherited from twisted.internet.protocol.Protocol: __provides__ `Special descriptor for class __provides__ The descriptor caches the implementedBy info, so that we can get declarations for objects without instance-specific interfaces a bit quicker. For example: >>> from zope.interface import Interface >>> class IFooFactory(Interface): ... pass >>> class IFoo(Interface): ... pass >>> class C(object): ... implements(IFoo) ... classProvides(IFooFactory) >>> [i.getName() for i in C.__provides__] ['IFooFactory'] >>> [i.getName() for i in C().__provides__] ['IFoo']` Data and other attributes inherited from twisted.internet.protocol.Protocol: __implemented__ = <implementedBy twisted.internet.protocol.Protocol> Methods inherited from twisted.internet.protocol.BaseProtocol: __providedBy__ = <zope.interface.declarations.Declaration object> Data and other attributes inherited from twisted.internet.protocol.BaseProtocol: connected = 0 transport = None Methods inherited from gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine: inReadEvent(self) `Tell the state machine it can read from the socket.` inWriteEvent(self) `Tell the state machine it can write to the socket.` outWriteEvent(self) `Called when a write operation completes. May be overridden in subclass.` setCloseOp(self) `Start a close operation.` setHandshakeOp(self, handshaker) `Start a handshake operation. @type handshaker: generator @param handshaker: A generator created by using one of the asynchronous handshake functions (i.e. handshakeServerAsync, or handshakeClientxxx(..., async=True).` setWriteOp(self, writeBuffer) `Start a write operation. @type writeBuffer: str @param writeBuffer: The string to transmit.` wantsReadEvent(self) `If the state machine wants to read. If an operation is active, this returns whether or not the operation wants to read from the socket. If an operation is not active, this returns None. @rtype: bool or None @return: If the state machine wants to read.` wantsWriteEvent(self) `If the state machine wants to write. If an operation is active, this returns whether or not the operation wants to write to the socket. If an operation is not active, this returns None. @rtype: bool or None @return: If the state machine wants to write.`