def stringReceived(self, frame):
tmi = TTransport.TMemoryBuffer(frame)
tmo = TTransport.TMemoryBuffer()
iprot = self.factory.iprot_factory.getProtocol(tmi)
oprot = self.factory.oprot_factory.getProtocol(tmo)
server_ctx = TwistedRpcConnectionContext(self.transport.socket)
d = self.factory.processor.process(iprot, oprot, server_ctx)
d.addCallbacks(self.processOk, self.processError,
callbackArgs=(tmo,))
def handle(self):
"""Handle requests.
WARNING! You must call prepare BEFORE calling handle.
"""
assert self.prepared, "You have to call prepare before handle"
rset, wset, xset = self._select()
for readable in rset:
if readable == self._read.fileno():
# don't care i just need to clean readable flag
self._read.recv(1024)
elif readable in self.socket.handles:
client_socket = self.socket.accept()
connection = Connection(client_socket, self)
self.clients[client_socket.fileno()] = connection
else:
connection = self.clients[readable]
connection.read()
if connection.status == WAIT_PROCESS:
itransport = TTransport.TMemoryBuffer(connection.message)
# Header protocol needs oprot == iprot. This implies the
# input memory buffer is reused for output too.
if isinstance(self.in_protocol, THeaderProtocolFactory):
omembuf = itransport
iprot = self.in_protocol.getProtocol(itransport)
oprot = iprot
else:
# Otherwise, assume we need a TFramedTransport.
omembuf = TTransport.TMemoryBuffer()
itransport = TTransport.TFramedTransport(itransport)
otransport = TTransport.TFramedTransport(omembuf)
iprot = self.in_protocol.getProtocol(itransport)
oprot = self.out_protocol.getProtocol(otransport)
if self.max_queue_size == 0 or \
self.tasks.qsize() <= self.max_queue_size:
self.tasks.put([
self.processor, iprot, oprot, omembuf, connection
])
else:
logging.error(
"Queue max size of %d exceeded. Request rejected.",
self.max_queue_size)
for writeable in wset:
self.clients[writeable].write()
for oob in xset:
if oob in self.clients:
connection = self.clients[oob]
connection.close()
def serialize(protocol_factory, thr):
# type: (Any, Any) -> AnyStr
"""Convenience method for serializing objects using the given
protocol factory and a TMemoryBuffer."""
transport = TTransport.TMemoryBuffer()
protocol = protocol_factory.getProtocol(transport)
thr.write(protocol)
if isinstance(protocol, THeaderProtocol.THeaderProtocol):
protocol.trans.flush()
return transport.getvalue()
def stringReceived(self, frame):
tr = TTransport.TMemoryBuffer(frame)
iprot = self._iprot_factory.getProtocol(tr)
(fname, mtype, rseqid) = iprot.readMessageBegin()
try:
method = self.recv_map[fname]
except KeyError:
method = getattr(self.client, 'recv_' + fname)
self.recv_map[fname] = method
method(iprot, mtype, rseqid)
def deserialize(protocol_factory, data, thr_out):
# type: (Any, AnyStr, T) -> T
"""Convenience method for deserializing objects using the given
protocol factory and a TMemoryBuffer. returns its thr_out
argument."""
transport = TTransport.TMemoryBuffer(data)
try:
protocol = protocol_factory.getProtocol(transport, thr_out.thrift_spec) # noqa: T484
except TypeError:
protocol = protocol_factory.getProtocol(transport)
if isinstance(protocol, THeaderProtocol.THeaderProtocol):
# this reads the THeader headers to detect what the underlying
# protocol is, as well as looking at transforms, etc.
protocol.trans.readFrame(0)
protocol.reset_protocol()
thr_out.read(protocol) # noqa: T484
return thr_out
def __thrift_to_json(x):
trans = TTransport.TMemoryBuffer()
proto = TSimpleJSONProtocol.TSimpleJSONProtocol(trans)
x.write(proto)
return json.loads(trans.getvalue())