def __init__(
self,
trans,
):
self.__trans = trans
self.__rbuf = StringIO()
self.__wbuf = StringIO()
def __init__(self, value=None):
"""value -- a value to read from for stringio
If value is set, this will be a transport for reading,
otherwise, it is for writing"""
self._readBuffer = StringIO(value or b"")
self._writeBuffer = StringIO()
self._open = True
def test_primitive_serialization(self):
val = int(12)
buf = TMemoryBuffer()
proto = TCompactProtocol(buf)
proto.writeI32(val)
reader = TCompactProtocol(StringIO(buf.getvalue()))
self.assertEqual(reader.readI32(), val)
def read(self, sz):
ret = self.__rbuf.read(sz)
if len(ret) != 0:
return ret
self.__rbuf = StringIO(self.__trans.read(max(sz, self.__rbuf_size)))
return self.__rbuf.read(sz)
def cstringio_refill(self, prefix, reqlen):
# self.__rbuf will already be empty here because fastproto doesn't
# ask for a refill until the previous buffer is empty. Therefore,
# we can start reading new frames immediately.
while len(prefix) < reqlen:
self.readFrame()
prefix += self.__rbuf.getvalue()
self.__rbuf = StringIO(prefix)
return self.__rbuf
def flush(self):
wout = self.__wbuf.getvalue()
wsz = len(wout)
# reset wbuf before write/flush to preserve state on underlying failure
self.__wbuf = StringIO()
# N.B.: Doing this string concatenation is WAY cheaper than making
# two separate calls to the underlying socket object. Socket writes in
# Python turn out to be REALLY expensive, but it seems to do a pretty
# good job of managing string buffer operations without excessive copies
buf = pack(b"!i", wsz) + wout
self.__trans.write(buf)
self.__trans.flush()
def cstringio_refill(self, partialread, reqlen):
retstring = partialread
if reqlen < self.__rbuf_size:
# try to make a read of as much as we can.
retstring += self.__trans.read(self.__rbuf_size)
# but make sure we do read reqlen bytes.
if len(retstring) < reqlen:
retstring += self.__trans.readAll(reqlen - len(retstring))
self.__rbuf = StringIO(retstring)
return self.__rbuf
def readFrame(self):
buff = self.__trans.readAll(4)
(sz,) = unpack(b"!i", buff)
self.__rbuf = StringIO(self.__trans.readAll(sz))
def flush(self):
out = self.__wbuf.getvalue()
# reset wbuf before write/flush to preserve state on underlying failure
self.__wbuf = StringIO()
self.__trans.write(out)
self.__trans.flush()
def __init__(self, trans, rbuf_size=DEFAULT_BUFFER):
self.__trans = trans
self.__wbuf = StringIO()
self.__rbuf = StringIO(b"")
self.__rbuf_size = rbuf_size