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