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))
