def __init__(self, name, fid, field, value, message=""):
TException.__init__(self, message)
self.struct_name = name
self.fid = fid
self.field = field
self.value = value
def read(self, iprot):
if iprot._fast_decode is not None and isinstance(
iprot.trans, TTransport.CReadableTransport
) and self.thrift_spec is not None:
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 0:
if ftype == TType.MAP:
self.success = {}
(_ktype22, _vtype23, _size21) = iprot.readMapBegin()
for _i25 in range(_size21):
_key26 = iprot.readI16()
_val27 = groupRes()
_val27.read(iprot)
self.success[_key26] = _val27
iprot.readMapEnd()
else:
iprot.skip(ftype)
elif fid == 1:
if ftype == TType.STRUCT:
self.ouch = TException()
self.ouch.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def process(self, iprot, oprot, server_ctx=None):
(name, type, seqid) = iprot.readMessageBegin()
if type != TMessageType.CALL and type != TMessageType.ONEWAY:
raise TException("TMultiplex protocol only supports CALL & ONEWAY")
if sys.version_info[0] >= 3 and isinstance(name, bytes):
name = name.decode("utf-8")
index = name.find(TMultiplexedProtocol.SEPARATOR)
if index < 0:
raise TException("Service name not found in message name: " +
name +
". Did you forget to use TMultiplexProtocol " +
"in your client?")
serviceName = name[0:index]
call = name[index + len(TMultiplexedProtocol.SEPARATOR):]
if sys.version_info[0] >= 3:
call = call.encode("utf-8")
if not serviceName in self.services:
raise TException("Service name not found: " + serviceName +
". Did you forget to call registerProcessor()?")
standardMessage = (call, type, seqid)
return self.services[serviceName].process(
StoredMessageProtocol(iprot, standardMessage), oprot, server_ctx)
def __init__(self, name, fid, field, value, message=""):
TException.__init__(self, message)
self.struct_name = name
self.fid = fid
self.field = field
self.value = value
def __init__(
self,
identifier=None,
key=None,
):
TException.__init__(self)
self.identifier = identifier
self.key = key
def __init__(
self,
errorCode=None,
message=None,
rateLimitDuration=None,
):
TException.__init__(self, message)
self.errorCode = errorCode
self.message = message
self.rateLimitDuration = rateLimitDuration
def process(self, iprot, oprot):
try:
if iprot.upgraded() is not None:
return self._underlying.process(iprot, oprot)
except AttributeError as e:
logging.exception("underlying protocol object is not a TFinagleServerProtocol", e)
return self._underlying.process(iprot, oprot)
(name, ttype, seqid) = iprot.readMessageBegin()
if ttype != TMessageType.CALL and ttype != TMessageType.ONEWAY:
raise TException("TFinagle protocol only supports CALL & ONEWAY")
# Check if this is an upgrade request.
if name == UPGRADE_METHOD:
connection_options = ConnectionOptions()
connection_options.read(iprot)
iprot.readMessageEnd()
oprot.writeMessageBegin(UPGRADE_METHOD, TMessageType.REPLY, seqid)
upgrade_reply = UpgradeReply()
upgrade_reply.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
iprot.set_upgraded(True)
oprot.set_upgraded(True)
return True
# Not upgraded. Replay the message begin to the underlying processor.
iprot.set_upgraded(False)
oprot.set_upgraded(False)
msg = (name, ttype, seqid)
return self._underlying.process(StoredMessageProtocol(iprot, msg), oprot)
def read_frame(trans):
frame_header = trans.readAll(4)
sz, = struct.unpack('!i', frame_header)
if sz < 0:
raise TException('client must use TFramedTransport')
frame_data = trans.readAll(sz)
return frame_data
def testException(self, arg):
# if options.verbose > 1:
logging.info('testException(%s)' % arg)
if arg == 'Xception':
raise Xception(errorCode=1001, message=arg)
elif arg == 'TException':
raise TException(message='This is a TException')
def process(self, iprot, oprot):
(name, type, seqid) = iprot.readMessageBegin()
if type != TMessageType.CALL and type != TMessageType.ONEWAY:
raise TException("TMultiplexed protocol only supports CALL & ONEWAY")
index = name.find(TMultiplexedProtocol.SEPARATOR)
if index < 0:
raise TException("Service name not found in message name: " + name + ". Did you forget to use TMultiplexedProtocol in your client?")
serviceName = name[0:index]
call = name[index + len(TMultiplexedProtocol.SEPARATOR):]
if serviceName not in self.services:
raise TException("Service name not found: " + serviceName + ". Did you forget to call registerProcessor()?")
standardMessage = (call, type, seqid)
return self.services[serviceName].process(StoredMessageProtocol(iprot, standardMessage), oprot)
def _process(self, iprot):
"""
Extract the service name and the StoredMessageProtocol
representation of the input protocol message.
raises: TException if i_msg is invalid or service name is not known.
returns: service_name, m_iprot
"""
# Check if we are shutting down.
if self.shutting_down:
self._logger.warning("Processor shutting down, failing request")
raise TException("Processor shuttind down")
# Check if it is a valid message
(name, m_type, seqid) = iprot.readMessageBegin()
if m_type != TMessageType.CALL & m_type != TMessageType.ONEWAY:
self._logger.warning(
"Invalid message: This should not have happened")
raise TException("Invalid message type")
# Check if we can find the service name
index = name.find(SEPARATOR)
if index < 0:
self._logger.warning(
"Service name not found in message name: " + name +
". Did you forget to use TMultiplexProtocol in your client?")
raise TException("Service name not found")
# Check that we know of the service
service_name = name[0:index]
m_call = name[index + len(SEPARATOR):]
if service_name not in self.services:
self._logger.warning(
"Service name not found: " + service_name +
". Did you forget to call registerProcessor()?")
raise TException("Service not found")
# Check if the queue is already backed up.
if (self.services[service_name].is_full()):
err = "Queue is full for service: %s" % service_name
self._logger.warning(err)
raise TException(err)
standardMessage = (m_call, m_type, seqid)
m_iprot = StoredMessageProtocol(iprot, standardMessage)
return service_name, m_iprot
def handle(client, addr, framed=True):
fd = client.fileno()
log.info('func=open|client=%s:%d', addr[0], addr[1])
global service
if not service:
raise TException('service not initial')
def read_frame(trans):
frame_header = trans.readAll(4)
sz, = struct.unpack('!i', frame_header)
if sz < 0:
raise TException('client must use TFramedTransport')
frame_data = trans.readAll(sz)
return frame_data
def unpack_name(s):
sz, = struct.unpack('!i', s[4:8])
return s[8:8 + sz]
tstart = time.time()
trans = TSocket.TSocket(addr[0], addr[1])
trans.setHandle(client)
try:
#frame_data = read_frame(trans)
#log.debug('data:%s %s', repr(frame_data), unpack_name(frame_data))
#itran = TTransport.TMemoryBuffer(frame_data)
if framed:
itran = TTransport.TFramedTransport(trans)
otran = TTransport.TFramedTransport(trans)
else:
itran = TTransport.TBufferedTransport(trans)
otran = TTransport.TBufferedTransport(trans)
iprot = TBinaryProtocol.TBinaryProtocol(itran, False, True)
oprot = TBinaryProtocol.TBinaryProtocol(otran, False, True)
service.handler.remote = addr
p = service.Processor(service.handler)
while True:
p.process(iprot, oprot)
#log.info('func=call|name=%s|time=%d', unpack_name(frame_data), (time.time()-tstart)*1000000)
#itran.close()
#otran.close()
except TTransport.TTransportException as tx:
if tx.type == TTransport.TTransportException.END_OF_FILE:
pass
else:
log.error(traceback.format_exc())
except EOFError:
#log.error(traceback.format_exc())
#log.info('func=close|time=%d', addr[0], addr[1], (timt.time()-tstart)*1000)
pass
except Exception as e:
log.error(traceback.format_exc())
finally:
log.info('func=close|time=%d', (time.time() - tstart) * 1000000)
client.close()
def setEventHandler(self, event_handler, serviceName=None):
"""Set event handler for a service. If serviceName is None,
set event handler for all services"""
if serviceName is not None:
if not serviceName in self.services:
raise TException("Cannot set event handler for service " +
serviceName + ": no such service")
else:
self.services[serviceName].setEventHandler(event_handler)
else:
for processor in self.services.values():
processor.setEventHandler(event_handler)
def test_process_processor_exception(self):
processor = FBaseProcessor()
proc = Mock()
e = TException(message='foo bar exception')
proc.process.side_effect = e
processor.add_to_processor_map("basePing", proc)
frame = bytearray(
b'\x00\x00\x00\x00\x0e\x00\x00\x00\x05_opid\x00\x00\x00\x011'
b'\x80\x01\x00\x02\x00\x00\x00\x08basePing\x00\x00\x00\x00\x00')
itrans = TMemoryBuffer(value=frame)
iprot = FProtocolFactory(TBinaryProtocolFactory()).get_protocol(itrans)
oprot = Mock()
processor.process(iprot, oprot)
def open(self, **kwargs):
#===================================================================================================================
# add by mz
error_type = kwargs.get("error_type")
if error_type:
from thrift.transport.TTransport import TTransportException
from thrift.protocol.TProtocol import TProtocolException
from thrift.Thrift import TException, TApplicationException
get_error = {
"TTransportException": TTransportException(),
"TProtocolException": TProtocolException(),
"TException": TException(),
"TApplicationException": TApplicationException()
}
error_ = get_error[error_type]
raise error_
from thrift.transport.TTransport import TTransportException
#===================================================================================================================
try:
res0 = self._resolveAddr()
for res in res0:
self.handle = socket.socket(res[0], res[1])
self.handle.settimeout(self._timeout)
try:
self.handle.connect(res[4])
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 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 __init__(self, type=UNKNOWN, message=None):
TException.__init__(self, message)
self.type = type
def __init__(self, type=UNKNOWN, message=None): TException.__init__(self, message) self.type = type
def __init__(self, identifier=None, key=None,): TException.__init__(self) self.identifier = identifier self.key = key
def __init__(self, errorCode=None, message=None, rateLimitDuration=None,): TException.__init__(self, message) self.errorCode = errorCode self.message = message self.rateLimitDuration = rateLimitDuration
class queryBrand_result(object):
"""
Attributes:
- success
- ouch
"""
def __init__(
self,
success=None,
ouch=None,
):
self.success = success
self.ouch = ouch
def read(self, iprot):
if iprot._fast_decode is not None and isinstance(
iprot.trans, TTransport.CReadableTransport
) and self.thrift_spec is not None:
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 0:
if ftype == TType.MAP:
self.success = {}
(_ktype22, _vtype23, _size21) = iprot.readMapBegin()
for _i25 in range(_size21):
_key26 = iprot.readI16()
_val27 = groupRes()
_val27.read(iprot)
self.success[_key26] = _val27
iprot.readMapEnd()
else:
iprot.skip(ftype)
elif fid == 1:
if ftype == TType.STRUCT:
self.ouch = TException()
self.ouch.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot._fast_encode is not None and self.thrift_spec is not None:
oprot.trans.write(
oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
return
oprot.writeStructBegin('queryBrand_result')
if self.success is not None:
oprot.writeFieldBegin('success', TType.MAP, 0)
oprot.writeMapBegin(TType.I16, TType.STRUCT, len(self.success))
for kiter28, viter29 in self.success.items():
oprot.writeI16(kiter28)
viter29.write(oprot)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.ouch is not None:
oprot.writeFieldBegin('ouch', TType.STRUCT, 1)
self.ouch.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value) for key, value in self.__dict__.items()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other,
self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class TSocketPool(TSocket):
serverStates = {}
# TSocketPool([('192.168.10.85', 8090), ('192.168.10.87', 9090)])
# or TSocketPool('192.168.10.86', 8754)
def __init__(self, host, port=9090):
TSocket.__init__(self)
self.servers = []
self.randomize = True
self.retryInterval = 60
self.numRetries = 1
self.maxConsecutiveFailures = 1
self.alwaysTryLast = True
if type(port) is list:
for i in range(0, len(port)):
self.servers.append((host[i], int(port[i])))
else:
if type(host) is list:
self.servers = host
else:
self.servers = [(
host,
int(port),
)]
def open(self):
# Check if we want order randomization
servers = self.servers
if self.randomize:
servers = []
oldServers = []
oldServers.extend(self.servers)
while len(oldServers):
posn = int(random() * len(oldServers))
servers.append(oldServers[posn])
oldServers[posn] = oldServers[-1]
oldServers.pop()
# Count servers to identify the "last" one
for i in range(0, len(servers)):
# This extracts the $host and $port variables
host, port = servers[i]
# Check APC cache for a record of this server being down
failtimeKey = 'thrift_failtime:%s%d~' % (host, port)
# Cache miss? Assume it's OK
lastFailtime = TSocketPool.serverStates.get(failtimeKey, 0)
retryIntervalPassed = False
# Cache hit...make sure enough the retry interval has elapsed
if lastFailtime > 0:
elapsed = int(time.time()) - lastFailtime
if elapsed > self.retryInterval:
retryIntervalPassed = True
# Only connect if not in the middle of a fail interval, OR if this
# is the LAST server we are trying, just hammer away on it
isLastServer = self.alwaysTryLast and i == (len(servers) -
1) or False
if lastFailtime == 0 or isLastServer or (lastFailtime > 0
and retryIntervalPassed):
# Set underlying TSocket params to this one
self.host = host
self.port = port
# Try up to numRetries_ connections per server
for attempt in range(0, self.numRetries):
try:
# Use the underlying TSocket open function
TSocket.open(self)
# Only clear the failure counts if required to do so
if lastFailtime > 0:
TSocketPool.serverStates[failtimeKey] = 0
# Successful connection, return now
return
except TTransportException, e:
# Connection failed
pass
# Mark failure of this host in the cache
consecfailsKey = 'thrift_consecfails:%s%d~' % (host, port)
# Ignore cache misses
consecfails = TSocketPool.serverStates.get(consecfailsKey, 0)
# Increment by one
consecfails += 1
# Log and cache this failure
if consecfails >= self.maxConsecutiveFailures:
# Store the failure time
TSocketPool.serverStates[failtimeKey] = int(time.time())
# Clear the count of consecutive failures
TSocketPool.serverStates[consecfailsKey] = 0
else:
TSocketPool.serverStates[consecfailsKey] = consecfails
# Oh no; we failed them all. The system is totally ill!
error = 'TSocketPool: All hosts in pool are down. '
hostlist = ','.join(['%s:%d' % (s[0], s[1]) for s in self.servers])
error += '(%s)' % hostlist
raise TException(error)