def _recv_basePing(self, ctx):
self._iprot.read_response_headers(ctx)
_, mtype, _ = self._iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(self._iprot)
self._iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = basePing_result()
result.read(self._iprot)
self._iprot.readMessageEnd()
return
def _read_frame(self):
header = self._trans.read(4)
(length, ) = struct.unpack(">I", header)
if self.encode:
# If the frames are encoded (i.e. you're using a QOP of auth-int or
# auth-conf), then make sure to include the header in the bytes you send to
# sasl.decode()
encoded = header + self._trans.read(length)
success, decoded = self.sasl.decode(encoded)
if not success:
raise TTransportException(type=TTransportException.UNKNOWN,
message=self.sasl.getError())
else:
# If the frames are not encoded, just pass it through
decoded = self._trans.read(length)
self.__rbuf = BufferIO(decoded)
def open(self):
try:
for host in self.hosts:
try:
self.handle = concurrence.io.Socket.connect(
host, self.timeout)
self.stream = concurrence.io.BufferedStream(self.handle)
except socket.error as e:
if host is not self.hosts[-1]:
continue
else:
raise e
break
except socket.error as e:
message = "Could not connect to thrift socket"
raise TTransportException(TTransportException.NOT_OPEN, message)
def read(self, sz):
logging.debug("reading %d bytes from %s:%d" %
(sz, self.host, self.port))
cur_gr = greenlet.getcurrent()
def _on_read(buf):
if self._stream:
cur_gr.switch(buf)
self._stream.read_bytes(sz, _on_read)
buf = cur_gr.parent.switch()
if len(buf) == 0:
raise TTransportException(type=TTransportException.END_OF_FILE,
message='TTornadoTransport read 0 bytes')
logging.debug("read %d bytes in %.2fms" %
(len(buf), (time.time() - self._start_time) * 1000))
return buf
def _recv_enterAlbumGiveaway(self, ctx):
self._iprot.read_response_headers(ctx)
_, mtype, _ = self._iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(self._iprot)
self._iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(type=TTransportExceptionType.RESPONSE_TOO_LARGE, message=x.message)
raise x
result = enterAlbumGiveaway_result()
result.read(self._iprot)
self._iprot.readMessageEnd()
if result.success is not None:
return result.success
x = TApplicationException(TApplicationExceptionType.MISSING_RESULT, "enterAlbumGiveaway failed: unknown result")
raise x
def open(self):
try:
res0 = self._resolveAddr()
for res in res0:
sock_family, sock_type = res[0:2]
ip_port = res[4]
plain_sock = socket.socket(sock_family, sock_type)
context = ssl.SSLContext(self.SSL_VERSION)
if self.ciphers:
context.set_ciphers(self.ciphers)
if not self.validate:
context.verify_mode = ssl.CERT_NONE
else:
context.verify_mode = ssl.CERT_REQUIRED
if self.certfile:
context.load_cert_chain(certfile=self.certfile,
keyfile=self.keyfile)
if self.capath:
context.load_verify_locations(cafile=None,
capath=self.capath)
self.handle = ssl.SSLSocket(plain_sock,
do_handshake_on_connect=True,
_context=context)
self.handle.settimeout(self._timeout)
try:
self.handle.connect(ip_port)
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 secure socket %s: %s' \
% (self._unix_socket, e)
else:
message = 'Could not connect to %s:%d: %s' % (self.host,
self.port, e)
raise TTransportException(type=TTransportException.NOT_OPEN,
message=message)
if self.validate:
self._validate_cert()
def __init__(self,
uri,
auth=None,
session_factory=default_requests_session_factory,
user_agent=DEFAULT_USER_AGENT):
"""Construct a TRequestsTransport.
Construct a Thrift transport based upon the requests module. URI is the
HTTP endpoint that the server should be listening on. The 'auth'
keyword is passed directly to the requests client and can be used to
provide different authentication contexts such as Kerberos
authentication via the requests-kerberos module.
:param uri: The endpoint uri
:type uri: str
:keyword auth: The requests authentication context
:type auth: requests.auth.AuthBase
:keyword session_factory: A callable that returns a requests session
:type session_factory: () -> requests.Session
:keyword user_agent: The value to use for the User-Agent header
:type user_agent: str
"""
self._session = None
self.__session_factory = session_factory
if not callable(session_factory):
raise TypeError(
'session_factory should be a callable that produces a requests.Session!'
)
self.__user_agent = user_agent
self.__wbuf = BytesIO()
self.__rbuf = BytesIO()
self.__uri = uri
try:
self.__urlparse = urlparse(uri)
except ValueError:
raise TTransportException('Failed to parse uri %r' % (uri, ))
self.__timeout = None
if auth is not None and not isinstance(auth, requests.auth.AuthBase):
raise TypeError(
'Invalid auth type. Expected: %s but got %s' %
(requests.auth.AuthBase.__name__, auth.__class__.__name__))
self.__auth = auth
# Silence requests logs so we don't get messages for every HTTP connection.
logging.getLogger('requests').setLevel(logging.WARNING)
async def _make_request(self, context:FContext, payload): async with ClientSession() as session: try: if self._timeout > 0: with async_timeout.timeout(self._timeout / 1000): async with session.post(self._url, data=payload, headers=self._headers) \ as response: return response.status, await response.content.read() else: async with session.post(self._url,data=payload,headers=self._headers) as response: return response.status, await response.content.read() except asyncio.TimeoutError: raise TTransportException( type=TTransportExceptionType.TIMED_OUT, message='request timed out' )
def create_named_pipe(self):
openMode = win32pipe.PIPE_ACCESS_DUPLEX | win32file.FILE_FLAG_OVERLAPPED
pipeMode = win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_READMODE_BYTE
saAttr = pywintypes.SECURITY_ATTRIBUTES()
saAttr.SetSecurityDescriptorDacl(1, None, 0)
self._handle = win32pipe.CreateNamedPipe(
self._pipe_name, openMode, pipeMode,
win32pipe.PIPE_UNLIMITED_INSTANCES, self._buff_size,
self._buff_size, win32pipe.NMPWAIT_WAIT_FOREVER, saAttr)
err = win32api.GetLastError()
if self._handle.handle == winerror.ERROR_INVALID_HANDLE:
raise TTransportException(
type=TTransportException.NOT_OPEN,
message='Tcreate_named_pipe failed: {}'.format(err))
return True
def _recv_postSnsInvitationMessage(self, ctx):
self._iprot.read_response_headers(ctx)
_, mtype, _ = self._iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(self._iprot)
self._iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = postSnsInvitationMessage_result()
result.read(self._iprot)
self._iprot.readMessageEnd()
if result.e is not None:
raise result.e
return
def open(self, timeout=None):
logger.debug('socket connecting')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
self.stream = iostream.IOStream(sock)
try:
connect = self.stream.connect((self.host, self.port))
if timeout is not None:
yield self.with_timeout(timeout, connect)
else:
yield connect
except (socket.error, IOError, ioloop.TimeoutError) as e:
message = 'could not connect to {}:{} ({})'.format(self.host, self.port, e)
raise TTransportException(
type=TTransportException.NOT_OPEN,
message=message)
raise gen.Return(self)
def open(self):
try:
addrs = self._resolveAddr()
for res in addrs:
ip_port = res[4]
plain_sock = self._setup_tunnel(ip_port)
plain_sock.settimeout(self._timeout)
self.handle = ssl.wrap_socket(plain_sock,
certfile=self.ca_certs,
ssl_version=ssl.PROTOCOL_TLSv1_2)
self.handle.settimeout(self._timeout)
except socket.error, e:
if self._unix_socket:
message = 'Could not connect to secure socket %s' % self._unix_socket
else:
message = 'Could not connect to %s:%d' % (self.host, self.port)
raise TTransportException(type=TTransportException.NOT_OPEN,
message=message)
class TSSLSocketWithWildcardSAN(TSSLSocket.TSSLSocket):
"""
This is a subclass of thrift's TSSLSocket which has been extended to add the missing
functionality of validating wildcard certificates and certificates with SANs
(subjectAlternativeName).
The core of the validation logic is based on the python-ssl library:
See <https://svn.python.org/projects/python/tags/r32/Lib/ssl.py>
"""
def __init__(self,
host='localhost',
port=9090,
validate=True,
ca_certs=None,
unix_socket=None):
TSSLSocket.TSSLSocket.__init__(self, host, port, validate, ca_certs,
unix_socket)
# Set client protocol choice to be very permissive, as we rely on servers to enforce
# good protocol selection. This value is forwarded to the ssl.wrap_socket() API during
# open(). See https://docs.python.org/2/library/ssl.html#socket-creation for a table
# that shows a better option is not readily available for sockets that use
# wrap_socket().
self.SSL_VERSION = ssl.PROTOCOL_SSLv23
def _validate_cert(self):
cert = self.handle.getpeercert()
self.peercert = cert
if 'subject' not in cert:
raise TTransportException(
type=TTransportException.NOT_OPEN,
message='No SSL certificate found from %s:%s' %
(self.host, self.port))
try:
self._match_hostname(cert, self.host)
self.is_valid = True
return
except CertificateError, ce:
raise TTransportException(
type=TTransportException.UNKNOWN,
message='Certificate error with remote host: %s' % (ce))
raise TTransportException(
type=TTransportException.UNKNOWN,
message='Could not validate SSL certificate from '
'host "%s". Cert=%s' % (self.host, cert))
def _recv_retrieveOpenIdAuthUrlWithDocomo(self, ctx):
self._iprot.read_response_headers(ctx)
_, mtype, _ = self._iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(self._iprot)
self._iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(type=TTransportExceptionType.RESPONSE_TOO_LARGE, message=x.message)
raise x
result = retrieveOpenIdAuthUrlWithDocomo_result()
result.read(self._iprot)
self._iprot.readMessageEnd()
if result.e is not None:
raise result.e
if result.success is not None:
return result.success
x = TApplicationException(TApplicationExceptionType.MISSING_RESULT, "retrieveOpenIdAuthUrlWithDocomo failed: unknown result")
raise x
def __init__(self, host='127.0.0.1', port=9090):
self.socket_ = TSocket.TSocket(host, port)
self.transport_ = TTransport.TBufferedTransport(self.socket_)
self.protocol_ = TBinaryProtocolAccelerated(self.transport_)
self.client_ = directory_service.Client(self.protocol_)
ex = None
for i in range(3):
try:
self.transport_.open()
except TTransportException as e:
ex = e
continue
except Exception:
raise
else:
break
else:
raise TTransportException(
ex.type,
"Connection failed {}:{}: {}".format(host, port, ex.message))
def read(self, sz):
try:
buff = self.handle.recv(sz)
except socket.error as e:
if (e.args[0] == errno.ECONNRESET
and (sys.platform == 'darwin'
or sys.platform.startswith('freebsd'))):
# freebsd and Mach don't follow POSIX semantic of recv
# and fail with ECONNRESET if peer performed shutdown.
# See corresponding comment and code in TSocket::read()
# in lib/cpp/src/transport/TSocket.cpp.
self.close()
# Trigger the check to raise the END_OF_FILE exception below.
buff = ''
else:
raise
if len(buff) == 0:
raise TTransportException(type=TTransportException.END_OF_FILE,
message='TSocket read 0 bytes')
return buff
def _create_connection(self) -> TProtocolBase:
for _ in self.retry_policy:
trans = _make_transport(self.endpoint)
trans.setTimeout(self.timeout * 1000.0)
prot = self.protocol_factory.getProtocol(trans)
try:
prot.trans.open()
except TTransportException as exc:
logger.info("Failed to connect to %r: %s", self.endpoint, exc)
continue
prot.baseplate_birthdate = time.time()
return prot
raise TTransportException(
type=TTransportException.NOT_OPEN,
message="giving up after multiple attempts to connect",
)
def _call_thrift_method(self, name, *args, **kwargs):
trace_name = "{}.{}".format(self.namespace, name)
last_error = None
for _ in self.retry_policy:
try:
with self.server_span.make_child(trace_name) as span:
with self.pool.connection() as prot:
prot.trans.set_header(b"Trace",
str(span.trace_id).encode())
prot.trans.set_header(b"Parent",
str(span.parent_id).encode())
prot.trans.set_header(b"Span", str(span.id).encode())
if span.sampled is not None:
sampled = "1" if span.sampled else "0"
prot.trans.set_header(b"Sampled", sampled.encode())
if span.flags:
prot.trans.set_header(b"Flags",
str(span.flags).encode())
try:
edge_context = span.context.raw_request_context
except AttributeError:
edge_context = None
if edge_context:
prot.trans.set_header(b"Edge-Request",
edge_context)
client = self.client_cls(prot)
method = getattr(client, name)
return method(*args, **kwargs)
except TTransportException as exc:
last_error = exc
continue
raise TTransportException(
type=TTransportException.TIMED_OUT,
message="retry policy exhausted while attempting operation, "
"last error was: {}".format(last_error),
)
def _sock_accept(self):
if self._queue:
return self._queue.pop()
if hasattr(select, "epoll"):
poller = ConnectionEpoll()
else:
poller = ConnectionSelect()
for filenos in self.handles.keys():
poller.read(filenos)
r, _, x = poller.process(0)
for fd in r:
self._queue.append(self.handles[fd].accept())
if not self._queue:
raise TTransportException("Accept interrupt without client?")
return self._queue.pop()
def open(self) -> None:
# if we are not on Windows or the socktype is not unix socket, return
# the parent TSocket
if not self._shouldUseWinsocket:
return super(WinTSocket, self).open()
handle = WindowsSocketHandle()
self.setHandle(handle)
handle.settimeout(self._timeout)
try:
handle.connect(self._unix_socket)
except OSError as e:
self.close()
if e.errno == errno.ECONNREFUSED:
# This error will be returned when Edenfs is not running
raise TTransportException(type=TTransportException.NOT_OPEN,
message="eden not running")
raise e
except Exception:
self.close()
raise
def listen(self):
res0 = self._resolveAddr(self.family)
for res in res0:
if res[0] == socket.AF_INET6 and res[4][0] == socket.AF_INET6:
# This happens if your version of python was built without IPv6
# support. getaddrinfo() will return IPv6 addresses, but the
# contents of the address field are bogus.
# (For example, see http://bugs.python.org/issue8858)
#
# Ignore IPv6 addresses if python doesn't have IPv6 support.
continue
# We need remove the old unix socket if the file exists and
# nobody is listening on it.
if self._unix_socket:
self._cleanup_unix_socket(res)
# Don't complain if we can't create a socket
# since this is handled below.
try:
handle = socket.socket(res[0], res[1])
except Exception:
continue
handle.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._setHandleCloseOnExec(handle)
# Always set IPV6_V6ONLY for IPv6 sockets when not on Windows
if res[0] == socket.AF_INET6 and sys.platform != 'win32':
handle.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY,
True)
handle.settimeout(None)
handle.bind(res[4])
handle.listen(self.tcp_backlog)
self.handles[handle.fileno()] = handle
if not self.handles:
raise TTransportException("No valid interfaces to listen on!")
class TSSLSocketWithWildcardSAN(TSSLSocket.TSSLSocket):
"""
This is a subclass of thrift's TSSLSocket which has been extended to add the missing
functionality of validating wildcard certificates and certificates with SANs
(subjectAlternativeName).
The core of the validation logic is based on the python-ssl library:
See <https://svn.python.org/projects/python/tags/r32/Lib/ssl.py>
"""
def __init__(self,
host='localhost',
port=9090,
validate=True,
ca_certs=None,
unix_socket=None,
keyfile=None,
certfile=None):
TSSLSocket.TSSLSocket.__init__(self, host, port, validate, ca_certs,
keyfile, certfile, unix_socket)
def _validate_cert(self):
cert = self.handle.getpeercert()
self.peercert = cert
if 'subject' not in cert:
raise TTransportException(
type=TTransportException.NOT_OPEN,
message='No SSL certificate found from %s:%s' %
(self.host, self.port))
try:
self._match_hostname(cert, self.host)
self.is_valid = True
return
except CertificateError, ce:
raise TTransportException(
type=TTransportException.UNKNOWN,
message='Certificate error with remote host: %s' % (ce))
raise TTransportException(
type=TTransportException.UNKNOWN,
message='Could not validate SSL certificate from '
'host "%s". Cert=%s' % (self.host, cert))
async def _make_request(self, context: FContext, payload):
"""
Helper method to make a request over the network.
Args:
payload: The data to be sent over the network.
Return:
The status code and body of the response.
Throws:
TTransportException if the request timed out.
"""
with ClientSession() as session:
try:
with async_timeout.timeout(context.timeout / 1000):
async with session.post(self._url,
data=payload,
headers=self._headers) as response:
return response.status, await response.content.read()
except asyncio.TimeoutError:
raise TTransportException(
type=TTransportExceptionType.TIMED_OUT,
message='request timed out')
def open(self):
try:
res0 = self._resolveAddr()
for res in res0:
sock_family, sock_type = res[0:2]
ip_port = res[4]
plain_sock = socket.socket(sock_family, sock_type)
# check and turn on TCP Keepalive
sockprops = plain_sock.getsockopt(socket.SOL_SOCKET,
socket.SO_KEEPALIVE)
if (sockprops == 0):
sockprops = plain_sock.setsockopt(socket.SOL_SOCKET,
socket.SO_KEEPALIVE, 1)
self.handle = ssl.wrap_socket(plain_sock,
ssl_version=self.SSL_VERSION,
do_handshake_on_connect=True,
ca_certs=self.ca_certs,
keyfile=self.keyfile,
certfile=self.certfile,
cert_reqs=self.cert_reqs)
self.handle.settimeout(self._timeout)
try:
self.handle.connect(ip_port)
except socket.error, e:
if res is not res0[-1]:
continue
else:
raise e
break
except socket.error, e:
if self._unix_socket:
message = 'Could not connect to secure socket %s: %s' \
% (self._unix_socket, e)
else:
message = 'Could not connect to %s:%d: %s' % (self.host,
self.port, e)
raise TTransportException(type=TTransportException.NOT_OPEN,
message=message)
async def _basePing(self, ctx):
memory_buffer = TMemoryOutputBuffer(self._transport.get_request_size_limit())
oprot = self._protocol_factory.get_protocol(memory_buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin('basePing', TMessageType.CALL, 0)
args = basePing_args()
args.write(oprot)
oprot.writeMessageEnd()
response_transport = await self._transport.request(ctx, memory_buffer.getvalue())
iprot = self._protocol_factory.get_protocol(response_transport)
iprot.read_response_headers(ctx)
_, mtype, _ = iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(type=TTransportExceptionType.RESPONSE_TOO_LARGE, message=x.message)
raise x
result = basePing_result()
result.read(iprot)
iprot.readMessageEnd()
async def _getAuthQrcode(self, ctx, keepLoggedIn, systemName,
returnCallbackUrl):
memory_buffer = TMemoryOutputBuffer(
self._transport.get_request_size_limit())
oprot = self._protocol_factory.get_protocol(memory_buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin('getAuthQrcode', TMessageType.CALL, 0)
args = getAuthQrcode_args()
args.keepLoggedIn = keepLoggedIn
args.systemName = systemName
args.returnCallbackUrl = returnCallbackUrl
args.write(oprot)
oprot.writeMessageEnd()
response_transport = await self._transport.request(
ctx, memory_buffer.getvalue())
iprot = self._protocol_factory.get_protocol(response_transport)
iprot.read_response_headers(ctx)
_, mtype, _ = iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = getAuthQrcode_result()
result.read(iprot)
iprot.readMessageEnd()
if result.e is not None:
raise result.e
if result.success is not None:
return result.success
raise TApplicationException(TApplicationExceptionType.MISSING_RESULT,
"getAuthQrcode failed: unknown result")
def flush(self):
buffer = self.__wbuf.getvalue()
# The first time we flush data, we send it to sasl.encode()
# If the length doesn't change, then we must be using a QOP
# of auth and we should no longer call sasl.encode(), otherwise
# we encode every time.
if self.encode == None:
success, encoded = self.sasl.encode(buffer)
if not success:
raise TTransportException(type=TTransportException.UNKNOWN,
message=self.sasl.getError())
if (len(encoded) == len(buffer)):
self.encode = False
self._flushPlain(buffer)
else:
self.encode = True
self._trans.write(encoded)
elif self.encode:
self._flushEncoded(buffer)
else:
self._flushPlain(buffer)
self._trans.flush()
self.__wbuf = BufferIO()
def _reconnect(self):
"""
Method to rebuild the connection with thrift server. Should not be used by the user directly.
Returns: None
"""
if not self.transport.isOpen():
logger.info(
"Connection lose is detected and start reconnecting to the target thrift server."
)
for i in range(self._retry_times):
if self.transport.isOpen():
logger.info(
"Reconnection success after retrying {} times.".format(
i))
return True
self._rebuild_protocol()
try:
logger.info("Starting reconnection to thrift server.")
self.transport.open()
logger.info(
"Reconnection success after retrying {} times.".format(
i + 1))
return True
except TTransportException:
logger.error("Reconnected {} times but failed.".format(i +
1))
time.sleep(self._retry_timeout)
if not self.transport.isOpen():
logger.error(
"Failed to rebuild connection with target thrift server.")
raise TTransportException(
type=TTransportException.NOT_OPEN,
message=
"Failed to rebuild connection with target thrift server.")
return False
def open(self):
try:
res0 = self._resolveAddr()
for res in res0:
sock_family, sock_type= res[0:2]
ip_port = res[4]
plain_sock = socket.socket(sock_family, sock_type)
self.handle = ssl.wrap_socket(plain_sock, ssl_version=self.SSL_VERSION,
do_handshake_on_connect=True, ca_certs=self.ca_certs, cert_reqs=self.cert_reqs)
self.handle.settimeout(self._timeout)
try:
self.handle.connect(ip_port)
except socket.error, e:
if res is not res0[-1]:
continue
else:
raise e
break
except socket.error, e:
if self._unix_socket:
message = 'Could not connect to secure socket %s' % self._unix_socket
else:
message = 'Could not connect to %s:%d' % (self.host, self.port)
raise TTransportException(type=TTransportException.NOT_OPEN, message=message)
def _call_thrift_method(self, name, *args, **kwargs):
trace_name = "{}.{}".format(self.namespace, name)
last_error = None
for _ in self.retry_policy:
try:
with self.root_span.make_child(trace_name) as span:
with self.pool.connection() as prot:
prot.trans.set_header("Trace", str(span.trace_id))
prot.trans.set_header("Parent", str(span.parent_id))
prot.trans.set_header("Span", str(span.id))
client = self.client_cls(prot)
method = getattr(client, name)
return method(*args, **kwargs)
except TTransportException as exc:
last_error = exc
continue
else:
raise TTransportException(
type=TTransportException.TIMED_OUT,
message="retry policy exhausted while attempting operation, "
"last error was: {}".format(last_error),
)
