class _Connection(Protocol):
def __init__(self):
try:
Protocol.__init__(self)
except AttributeError:
pass
self.buffer = ""
self.drd = Deferred()
def connectionMade(self):
self.peer = self.transport.getPeer()
self.transport.pauseProducing()
try:
self.factory.handler(Connection(self))
except AttributeError:
pass
def dataReceived(self, data):
self.transport.pauseProducing()
self.buffer += data
self.drd.callback(self.buffer)
def resume(self):
# resumeProducing throws an AssertionError if the following
# condition isn't met; the right thing to do is just not
# resume, because subsequent IO operations will have an error
# for us.
if self.transport.connected and not self.transport.disconnecting:
self.transport.resumeProducing()
self.drd = Deferred()
def connectionLost(self, reason):
self.drd.callback(reason.value)
class _HttpClient(TwistedHTTPClient):
def __init__(self):
try:
TwistedHTTPClient.__init__(self)
except AttributeError:
pass
self.code = None
self.headers = ordereddict.OrderedDict()
self.connect_df = Deferred()
self.response_df = Deferred()
def connectionMade(self):
self.connect_df.callback(None)
def handleStatus(self, protocol, code, message):
self.code = code
def handleHeader(self, name, value):
self.headers[name] = value
def handleResponse(self, data):
self.response_df.callback(HttpResponse(self.code, self.headers, data))
def close(self):
if self.transport:
self.transport.loseConnection()
def __init__(self, sock=None, evlp=evlp):
asyncore.dispatcher.__init__(self, sock=sock, map=evlp._map)
self.paused = True
self.buffer = ""
self.wbuf = ""
self.drd = Deferred()
self.dwd = None
self.connect_df = Deferred()
def __init__(self):
try:
TwistedHTTPClient.__init__(self)
except AttributeError:
pass
self.code = None
self.headers = ordereddict.OrderedDict()
self.connect_df = Deferred()
self.response_df = Deferred()
def __init__(self):
try:
Protocol.__init__(self)
except AttributeError:
pass
self.buffer = ""
self.drd = Deferred()
def resume(self):
# resumeProducing throws an AssertionError if the following
# condition isn't met; the right thing to do is just not
# resume, because subsequent IO operations will have an error
# for us.
if self.transport.connected and not self.transport.disconnecting:
self.transport.resumeProducing()
self.drd = Deferred()
class _Connection(asyncore.dispatcher):
def __init__(self, sock=None, evlp=evlp):
asyncore.dispatcher.__init__(self, sock=sock, map=evlp._map)
self.paused = True
self.buffer = ""
self.wbuf = ""
self.drd = Deferred()
self.dwd = None
self.connect_df = Deferred()
def handle_connect(self):
self.connect_df.callback(None)
def handle_read(self):
if not self.paused:
self.buffer += self.recv(8192)
self.paused = True
self.drd.callback(self.buffer)
def resume(self):
self.paused = False
self.drd = Deferred()
def handle_close(self):
self.close()
self.drd.callback(None)
def write(self, data):
self.wbuf += data
self.dwd = Deferred()
def handle_write(self):
if self.wbuf:
sent = self.send(self.wbuf)
self.wbuf = self.wbuf[sent:]
if self.dwd and not self.wbuf:
self.dwd.callback(None)
self.dwd = None
def write(self, data):
self.wbuf += data
self.dwd = Deferred()
def resume(self):
self.paused = False
self.drd = Deferred()
def write(self, data):
df = Deferred()
self._stream.write(data, lambda: df.callback(None))
return df
