def flush(self): if self._wbuffer_len: data = b"".join(self._wbuffer) self._wbuffer.clear() self._wbuffer_len = 0 else: data = b'' try: future = self._stream.write(data) except Exception as e: raise TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e)) if future.done(): return child_gr = greenlet.getcurrent() main = child_gr.parent assert main is not None, "Execut must be running in child greenlet" def write_callback(future): try: result = future.result() except Exception as e: return child_gr.throw( TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e))) return child_gr.switch(result) self._loop.add_future(future, write_callback) return main.switch()
def _reconnectOrThrowException(self, maxRetries, retry_interval): errors = 0 self.transport.close() while (errors < maxRetries): try: log.info('Attempting to reconnect') self.transport.open() log.info('Reconnection success') break except TTransport.TTransportException as e: log.error('Error - Reconnect fail') errors += 1 if errors < maxRetries: try: log.info( 'Waiting for milliseconds for retrying connect') time.sleep(retry_interval) except Exception as e: print e if errors >= maxRetries: raise TTransport.TTransportException("Connect failed")
def parseClientUnrouteableMessage(self, msg, channel, queue, thriftClient, iprot_factory=None): tr = TTransport.TMemoryBuffer(msg.content.body) if iprot_factory is None: iprot = self.factory.iprot_factory.getProtocol(tr) else: iprot = iprot_factory.getProtocol(tr) (fname, mtype, rseqid) = iprot.readMessageBegin() # log.msg('Got unroutable. fname = %r, rseqid = %s, mtype = %r, routing key = %r, client = %r, msg.content.body = %r' % (fname, rseqid, mtype, msg.routing_key, thriftClient, msg.content.body)) try: d = thriftClient._reqs.pop(rseqid) except KeyError: # KeyError will occur if the remote Thrift method is oneway, # since there is no outstanding local request deferred for # oneway calls. pass else: d.errback(TTransport.TTransportException( type=TTransport.TTransportException.NOT_OPEN, message='Unrouteable message, routing key = %r calling function %r' % (msg.routing_key, fname))) d = queue.get() d.addCallback(self.parseClientUnrouteableMessage, channel, queue, thriftClient, iprot_factory=iprot_factory) d.addErrback(self.catchClosedClientQueue) d.addErrback(self.handleClientQueueError)
def write_callback(future): try: result = future.result() except Exception as e: return child_gr.throw( TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e))) return child_gr.switch(result)
def connect(self, host, port): socket = TSocket.TSocket(host=host, port=port) self.transport = TTransport.TFramedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(trans=self.transport, strictRead=False, strictWrite=False) self.client = scribe.Client(iprot=protocol, oprot=protocol) self.connected = 1 self.thriftEx = TTransport.TTransportException()
def connectionLost(self, reason=connectionDone): while (self.client._reqs != {}): tmp = self.client._reqs self.client._reqs = {} for k, v in tmp.iteritems(): tex = TTransport.TTransportException( type=TTransport.TTransportException.END_OF_FILE, message='Connection closed') v.errback(tex)
def connectionLost(self, reason=connectionDone): for ( k, v, ) in self.client._reqs.iteritems(): tex = TTransport.TTransportException( type=TTransport.TTransportException.END_OF_FILE, message='Connection closed') v.errback(tex)
def connectionLost(self, reason=connectionDone): if sys.version_info[0] >= 3: client_req_iter = self.client._reqs.items() else: client_req_iter = self.client._reqs.items() for _, v in client_req_iter: tex = TTransport.TTransportException( type=TTransport.TTransportException.END_OF_FILE, message=self._errormsg or 'Connection closed') v.errback(tex)
def read_callback(future): try: data = future.result() except Exception as e: return child_gr.throw( TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e))) self._rbuffer = StringIO(partialread + data) return child_gr.switch(self._rbuffer)
def connectionLost(self, reason=connectionDone): 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 = "PROSES " \ "FINISH" raise TTransport.TTransportException(msg, message=msg) else: break else: msg = "STATUS: %d (%s)" % (status, challenge) raise TTransport.TTransportException(msg, message=msg) self._sasl_negotiation_deferred = None ThriftClientProtocol.connectionMade(self)
def connectionLost(self, reason): # the TTwisted version of this call does not account for the # possibility of other things happening during the errback. tex = TTransport.TTransportException( type=TTransport.TTransportException.END_OF_FILE, message='Connection closed (%s)' % reason) while self.client._reqs: k = iter(self.client._reqs).next() v = self.client._reqs.pop(k) v.errback(tex) del self.client._reqs del self.client
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 seak.vassar_server.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 read_callback(future): try: data = future.result() except Exception as e: return child_gr.throw( TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e))) if partialread_len + len(data) == sz: return child_gr.switch(bytes(partialread + data)) self._rbuffer = StringIO(data) return child_gr.switch(partialread + self._rbuffer.read(sz - partialread_len))
def write(self, data): data = to_tytes(data) self._wbuffer.append(data) self._wbuffer_len += len(data) if self._wbuffer_len >= self.DEFAULT_BUFFER: data = b"".join(self._wbuffer) self._wbuffer.clear() self._wbuffer_len = 0 try: self._stream.write(data) except Exception as e: raise TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e))
def _wait_for_transport(transport, num_retries=20, sleep_sec=1): """Open thrift transport. transport Transport to open num_retries Number of times to try opening transport before giving up sleep_sec Interval in seconds between retries """ for i in xrange(num_retries): try: transport.open() return except TTransport.TTransportException: time.sleep(sleep_sec) code = TTransport.TTransportException.TIMED_OUT raise TTransport.TTransportException(code, "Failed to open %s" % transport)
def test_performBackup_transport_exception(self, mock_wait, mock_client): mock_scheduler_client = mock.create_autospec( spec=scheduler_client.SchedulerClient, spec_set=False, instance=True) mock_thrift_client = mock.create_autospec(spec=AuroraAdmin.Client, instance=True) mock_thrift_client.performBackup.side_effect = TTransport.TTransportException('error') mock_scheduler_client.get_thrift_client.return_value = mock_thrift_client mock_client.get.return_value = mock_scheduler_client proxy = scheduler_client.SchedulerProxy(Cluster(name='local')) with pytest.raises(scheduler_client.SchedulerProxy.NotRetriableError): proxy.performBackup() assert mock_thrift_client.performBackup.call_count == 1 assert not mock_wait.called
def test_getTierConfigs_transport_exception(self, mock_wait, mock_client): mock_scheduler_client = mock.create_autospec( spec=scheduler_client.SchedulerClient, spec_set=False, instance=True) mock_thrift_client = mock.create_autospec(spec=AuroraAdmin.Client, instance=True) mock_thrift_client.getTierConfigs.side_effect = [ TTransport.TTransportException('error'), Response(responseCode=ResponseCode.OK) ] mock_scheduler_client.get_thrift_client.return_value = mock_thrift_client mock_client.get.return_value = mock_scheduler_client proxy = scheduler_client.SchedulerProxy(Cluster(name='local')) proxy.getTierConfigs(retry=True) assert mock_thrift_client.getTierConfigs.call_count == 2 assert mock_wait.call_count == 1
def open(self): """Open a connection. This is mostly copy pasta from thrift.transport.TSocket.open, but adds call to _setup_tunnel(). """ try: res0 = self._resolveAddr() for res in res0: try: self.handle = self._setup_tunnel(res[4]) self.handle.settimeout(self._timeout) except socket.error as e: if res is not res0[-1]: continue else: raise e break except socket.error as e: if self._unix_socket: message = 'Could not connect to socket %s' % self._unix_socket else: message = 'Could not connect to %s:%d' % (self.host, self.port) raise TTransport.TTransportException(type=TTransport.TTransportException.NOT_OPEN, message=message)
symbol = "" price = 0.0 size = 0 try: trans = TTransport.TFileObjectTransport(open("data", "wb")) trade = Trade() trade.symbol = "F" trade.price = 13.10 trade.size = 2500 trans.write(pickle.dumps(trade)) trans.close() if len(sys.argv) == 2: raise TTransport.TTransportException( TTransport.TTransportException.NOT_OPEN, "cmd line ex") trans = TTransport.TFileObjectTransport( open("data", ("wb" if len(sys.argv) > 2 else "rb"))) bstr = trans.read(128) trade = pickle.loads(bstr) print("Trade(%d): %s %d @ %f" % (len(bstr), trade.symbol, trade.size, trade.price)) except TTransport.TTransportException as tte: print("TTransportException(%d): %s" % (tte.type, tte)) except Thrift.TException as te: print("TException: %s" % te) except Exception as e: print("Exception: %s %s" % (type(e), e)) except:
def readAll(self, sz): try: return self.read(sz) except Exception as e: raise TTransport.TTransportException( TTransport.TTransportException.END_OF_FILE, str(e))