def _check_read(self, o): prot = self._slow(TTransport.TMemoryBuffer()) o.write(prot) slow_version_binary = prot.trans.getvalue() prot = self._fast( TTransport.TMemoryBuffer(slow_version_binary), fallback=False) c = o.__class__() c.read(prot) if c != o: print("actual : ") pprint(repr(c)) print("expected: ") pprint(repr(o)) raise Exception('read value mismatch') prot = self._fast( TTransport.TBufferedTransport( TTransport.TMemoryBuffer(slow_version_binary)), fallback=False) c = o.__class__() c.read(prot) if c != o: print("actual : ") pprint(repr(c)) print("expected: ") pprint(repr(o)) raise Exception('read value mismatch')
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) d = self.factory.processor.process(iprot, oprot) d.addCallbacks(self.processOk, self.processError, callbackArgs=(tmo,))
def render_POST(self, request): request.content.seek(0, 0) data = request.content.read() tmi = TTransport.TMemoryBuffer(data) tmo = TTransport.TMemoryBuffer() iprot = self.inputProtocolFactory.getProtocol(tmi) oprot = self.outputProtocolFactory.getProtocol(tmo) d = self.processor.process(iprot, oprot) d.addCallback(self._cbProcess, request, tmo) return server.NOT_DONE_YET
def _check_write(self, o): trans_fast = TTransport.TMemoryBuffer() trans_slow = TTransport.TMemoryBuffer() prot_fast = self._fast(trans_fast, fallback=False) prot_slow = self._slow(trans_slow) o.write(prot_fast) o.write(prot_slow) ORIG = trans_slow.getvalue() MINE = trans_fast.getvalue() if ORIG != MINE: print("actual : %s\nexpected: %s" % (repr(MINE), repr(ORIG))) raise Exception('write value mismatch')
def do_test(self): self._check_write(HolyMoley()) self._check_read(HolyMoley()) self._check_write(hm) no_set = deepcopy(hm) no_set.contain = set() self._check_read(no_set) self._check_read(hm) self._check_write(rs) self._check_read(rs) self._check_write(rshuge) self._check_read(rshuge) self._check_write(my_zero) self._check_read(my_zero) self._check_read(Backwards(**{"first_tag2": 4, "second_tag1": 2})) o = Backwards(**{"first_tag2": 4, "second_tag1": 2}) trans_fast = TTransport.TMemoryBuffer() trans_slow = TTransport.TMemoryBuffer() prot_fast = self._fast(trans_fast, fallback=False) prot_slow = self._slow(trans_slow) o.write(prot_fast) o.write(prot_slow) ORIG = trans_slow.getvalue() MINE = trans_fast.getvalue() assert id(ORIG) != id(MINE) prot = self._fast(TTransport.TMemoryBuffer(), fallback=False) o.write(prot) prot = self._slow( TTransport.TMemoryBuffer(prot.trans.getvalue())) c = o.__class__() c.read(prot) if c != o: print("copy: ") pprint(repr(c)) print("orig: ") pprint(repr(o))
def do_POST(self): # Don't care about the request path. itrans = TTransport.TFileObjectTransport(self.rfile) otrans = TTransport.TFileObjectTransport(self.wfile) itrans = TTransport.TBufferedTransport( itrans, int(self.headers['Content-Length'])) otrans = TTransport.TMemoryBuffer() iprot = thttpserver.inputProtocolFactory.getProtocol(itrans) oprot = thttpserver.outputProtocolFactory.getProtocol(otrans) try: thttpserver.processor.process(iprot, oprot) except ResponseException as exn: exn.handler(self) else: self.send_response(200) self.send_header("content-type", "application/x-thrift") self.end_headers() self.wfile.write(otrans.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 connectionLost(self, reason=connectionDone): # the called errbacks can add items to our client's _reqs, # so we need to use a tmp, and iterate until no more requests # are added during errbacks if self.client: tex = TTransport.TTransportException( type=TTransport.TTransportException.END_OF_FILE, message='Connection closed (%s)' % reason) while self.client._reqs: _, v = self.client._reqs.popitem() v.errback(tex) del self.client._reqs self.client = None
def connectionMade(self): self._sendSASLMessage(self.START, self.sasl.mechanism) initial_message = yield deferToThread(self.sasl.process) self._sendSASLMessage(self.OK, initial_message) while True: status, challenge = yield self._receiveSASLMessage() if status == self.OK: response = yield deferToThread(self.sasl.process, challenge) self._sendSASLMessage(self.OK, response) elif status == self.COMPLETE: if not self.sasl.complete: msg = "The server erroneously indicated that SASL " \ "negotiation was complete" raise TTransport.TTransportException(msg, message=msg) else: break else: msg = "Bad SASL negotiation status: %d (%s)" % (status, challenge) raise TTransport.TTransportException(msg, message=msg) self._sasl_negotiation_deferred = None ThriftClientProtocol.connectionMade(self)
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, selected = 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 == self.socket.handle.fileno(): try: client = self.socket.accept() if client: self.clients[client.handle.fileno()] = Connection(client.handle, self.wake_up) except socket.error: logger.debug('error while accepting', exc_info=True) else: connection = self.clients[readable] if selected: connection.read() if connection.received: connection.status = WAIT_PROCESS msg = connection.received.popleft() itransport = TTransport.TMemoryBuffer(msg.buffer, msg.offset) otransport = TTransport.TMemoryBuffer() iprot = self.in_protocol.getProtocol(itransport) oprot = self.out_protocol.getProtocol(otransport) self.tasks.put([self.processor, iprot, oprot, otransport, connection.ready]) for writeable in wset: self.clients[writeable].write() for oob in xset: self.clients[oob].close() del self.clients[oob]
def _deserialize(self, objtype, data): prot = self.protocol_factory.getProtocol(TTransport.TMemoryBuffer(data)) ret = objtype() ret.read(prot) return ret
def _serialize(self, obj): trans = TTransport.TMemoryBuffer() prot = self.protocol_factory.getProtocol(trans) obj.write(prot) return trans.getvalue()