def start_server(self): """ Registers the host and root scheduler processors and starts the thrift server. """ mux_processor = TMultiplexedProcessor.TMultiplexedProcessor() if self._hostHandler: self._register_processer("Host", mux_processor) if self._leafSchedulerHandler: self._register_processer("Scheduler", mux_processor) if self._rootSchedulerHandler: self._register_processer("RootScheduler", mux_processor) if self._enable_ping: self._register_processer("AgentControl", mux_processor) transport = TSocket.TServerSocket(self._address, self._port) protocol_factory = TCompactProtocol.TCompactProtocolFactory() self._server = TNonblockingServer.TNonblockingServer( mux_processor, transport, protocol_factory, protocol_factory) self._thread = threading.Thread(target=self._server.serve) self._thread.daemon = True self._thread.start() self._server_started = True self._logger.info( "[ThriftServer] Thrift server started. Address: {0} Port: {1}". format(self._address, self._port))
def _initialize_thrift_service(self): """ Initialize the thrift server. """ mux_processor = TMultiplexedProcessor.TMultiplexedProcessor() for plugin in thrift_services(): self._logger.info("Load thrift services %s (num_threads: %d)", plugin.name, plugin.num_threads) handler = plugin.handler processor = plugin.service.Processor(handler) mux_processor.registerProcessor(plugin.name, processor) self._logger.info( "Initialize SSLSocket using certfile=%s, keyfile=%s, capath=%s" % (SSL_CERT_FILE, SSL_KEY_FILE, CA_PATH)) transport = TSSLSocket.TSSLServerSocket(port=self._config.host_port, certfile=SSL_CERT_FILE, keyfile=SSL_KEY_FILE, capath=CA_PATH, ciphers=SSL_CIPHERS) protocol_factory = TCompactProtocol.TCompactProtocolFactory() server = TNonblockingServer.TNonblockingServer( mux_processor, transport, protocol_factory, protocol_factory, self._config.host_service_threads) self._server = server
def __init__(self, net: CaptchaBreaker, adPredictor: AdPredictor, host='127.0.0.1', port=48519): handler = APITransmitHandler(net, adPredictor) processor = BackendBridge.Processor(handler) transport = TSocket.TServerSocket(host, port) self.server = TNonblockingServer.TNonblockingServer(processor, transport) pass
def run(args): log_level = get_log_level(args.log_level) logger = logging.getLogger() logger.setLevel(log_level) if args.verbose: ch = logging.StreamHandler() ch.setLevel(log_level) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) logging.info("Starting pysnowflake server %s:%d" % (args.host, args.port)) handler = IdWorker(args.worker_id, args.data_center_id) processor = Snowflake.Processor(handler) transport = TSocket.TServerSocket(port=args.port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() logging.info("logging level: %s" % args.log_level) server = TNonblockingServer.TNonblockingServer(processor, transport, pfactory, threads=1) logging.info("RUNNING") server.serve()
def threaded_function(): handler = LucidaServiceHandler() processor = LucidaService.Processor(handler) transport = TSocket.TServerSocket(port=8080) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TNonblockingServer.TNonblockingServer(processor, transport, pfactory, pfactory) print 'CMD at', str(8080) server.serve()
def __init__(self, processor, port): self.processor = processor self.transport = TSocket.TServerSocket(port=port) self.tfactory = TTransport.TBufferedTransportFactory() self.pfactory = TBinaryProtocol.TBinaryProtocolFactory() #self.server = TServer.TThreadPoolServer(self.processor, self.transport , self.tfactory, self.pfactory) #self.server = TServer.TSimpleServer(self.processor, self.transport , self.tfactory, self.pfactory) self.server = TNonblockingServer.TNonblockingServer( self.processor, self.transport)
def start_clog_service(port): handler = CronLogServiceHandler() processor = CronLogService.Processor(handler) transport = TSocket.TServerSocket(port=port) tfactory = TTransport.TBufferedTransportFactory() tfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TNonblockingServer.TNonblockingServer( processor, transport, threads=20) print "Cassandra Log Server Running on port {port}...".format(port=port) server.serve()
def run(self): handler = BackEndHandler() proc = Processor(handler) trans_svr = TSocket.TServerSocket(port=self.portBE) proto_fac = TBinaryProtocol.TBinaryProtocolFactory() server = TNonblockingServer.TNonblockingServer(proc, trans_svr, proto_fac) print(f"[Server] Started on port {self.portBE}") server.serve()
def create_rpc_server(self, ps_host_name): sspHandler = SspHandler(self.num, self.max_stale) handler = sspHandler processor = CheckStaleness.Processor(handler) transport = TSocket.TServerSocket(host=ps_host_name, port=8000) tfactory = TTransport.TBufferedTransportFactory() rpcServer = TNonblockingServer.TNonblockingServer( processor, transport, threads=self.thread_num) tf.logging.info("Listening on port 8000...") return rpcServer
def create_rpc_server(self, ps_host_name): batchSizeHandler = BatchSizeHandler(self.initial_batch_size, self.num_of_replicas, self.thread_num) handler = batchSizeHandler processor = UpdateBatchSize.Processor(handler) #transport = TSocket.TServerSocket(ps_host_name, 8000) transport = TSocket.TServerSocket(host=ps_host_name, port=8000) tfactory = TTransport.TBufferedTransportFactory() # tfactory = TTransport.TFramedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() #rpcServer = TServer.TSimpleServer(processor,transport, tfactory, pfactory) rpcServer = TNonblockingServer.TNonblockingServer( processor, transport, threads=self.thread_num) tf.logging.info("Listening on port 8000...") return rpcServer
def serve(self): signal.signal(signal.SIGTERM, signal_handler) signal.signal(signal.SIGUSR1, signal_handler) processor = self.service.Processor(self.handler) tsocket = TSocket.TServerSocket(port=self.port) ttransport = TCompactProtocol.TCompactProtocolFactory() pfactory = TCompactProtocol.TCompactProtocolFactory() server = TNonblockingServer.TNonblockingServer(processor, tsocket, ttransport, pfactory) server.setNumThreads(self.threads_num) print datetime.now( ), ' Starting thrift server on port %d...' % self.port server.serve() print datetime.now(), ' thrift server quit.'
def main(): if len(sys.argv) < 2: print_usage() sys.exit(2) config_file = sys.argv[1] config = read_config(config_file) # asynchronous server handler = MindscribeHandler(config) processor = Mindscribe.Processor(handler) transport = TSocket.TServerSocket(config['port']) server = TNonblockingServer.TNonblockingServer(processor, transport) print 'Starting the server on port: ' + config['port'] server.serve() print 'done.'
def _initialize_thrift_service(self): """ Initialize the thrift server. """ mux_processor = TMultiplexedProcessor.TMultiplexedProcessor() for plugin in thrift_services(): self._logger.info("Load thrift services %s (num_threads: %d)", plugin.name, plugin.num_threads) handler = plugin.handler processor = plugin.service.Processor(handler) mux_processor.registerProcessor(plugin.name, processor) transport = TSocket.TServerSocket(port=self._config.host_port) protocol_factory = TCompactProtocol.TCompactProtocolFactory() server = TNonblockingServer.TNonblockingServer( mux_processor, transport, protocol_factory, protocol_factory, self._config.host_service_threads) self._server = server
def run(): if not readConf(): logService.info('read conf file is failed!') #print 'read conf file is failed!' return None # build news_infer_server if not hasValidPort(): logService.info("doesn't have valid port") #print "doesn't have valid port" return None handler = SameVideoHandler() valid_port = getPort() if valid_port == None: logService.info("doesn't have valid port") #print "doesn't have valid port" return None transport = TSocket.TServerSocket(port=valid_port) processor = SameVideoJudgeService.Processor(handler) #tfactory = TTransport.TBufferedTransportFactory() tfactory = TTransport.TFramedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() #server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) #server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) #server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) #server = TNonblockingServer.TNonblockingServer(processor, transport, tfactory, pfactory) server = TNonblockingServer.TNonblockingServer(processor, transport, pfactory) server.daemon = True server.setNumThreads(thread_num) #server.setNumWorkers(thread_num) print threading.current_thread() print('Starting the infer server...') server.serve() #logAll.error('done.') print('done')
def __initialize(self): pfactory = ThriftServer.__protocol_type[self._protocol]() if self._server_type == 'http': self._server = THttpServer.THttpServer(\ self._processor, (self._ip, self._port), pfactory) return transport = TSocket.TServerSocket(self._ip, self._port) if self._transport == 'zlib': transport = TZlibTransport.TZlibTransport(transport) tfactory = TZlibTransport.TZlibTransportFactory() else: tfactory = TTransport.TBufferedTransportFactory() if self._server_type == 'noblock': self._server = TNonblockingServer.TNonblockingServer(\ self._processor, transport, inputProtocolFactory=pfactory) else: self._server_type = ThriftServer.__server_type.get(self._server_type, 'TSimpleServer') ServerClass = getattr(TServer, self._server_type) self._server = ServerClass(self._processor, transport, tfactory, pfactory)
def main(): # 1. 创建 Thrift Server 的 ServeSocket serverSocket = TSocket.TServerSocket(host=host, port=port) # 3. 创建 Thrift Server 的 Protocol = 二进制传输协议 protocolFactory = TBinaryProtocol.TBinaryProtocolFactory() # 4. 创建 Thrift Server 提供的处理方法 handler = SpiderServiceHandler() # from message.api import MessageService processor = SpiderService.Processor(handler) # 5. 创建 Thrift Server, 指明如何处理,监听什么端口,传输方式,传输协议 # thriftServer = TServer.TSimpleServer(processor, # serverSocket, # transportFactory, # protocolFactory) thriftServer = TNonblockingServer.TNonblockingServer( processor, serverSocket, protocolFactory, protocolFactory) # 6. 启动 Thrift Server, 等待客户端的访问 print("Python Thrift Spider Server Start ...") thriftServer.serve() print("Python Thrift Spider Server Stop ...")
def _createThriftServer(self): buf_que = deque() handler = ScribeHandler(buf_que) protocol_factory = TBinaryProtocol.TBinaryProtocolFactory( False, False) transport = TSocket.TServerSocket(host='0.0.0.0') processor = Processor(handler) server = TNonblockingServer.TNonblockingServer( processor, transport, protocol_factory) server._stop = False while True: try: server.prepare() port = transport.handle.getsockname()[1] logger.info('get scribe port succeed: %d', port) break except socket.error: pass spawn(server.serve) return server, port, buf_que
def init_connection(self, processor): ''' Initialize all connections with TBinaryProtocol and TFramedTransport Parameters ---------- processor : TProcessor Processor class has been generated by thrift Returns ------- server: TServer TNonblocking Server ''' socket = TSocket.TServerSocket(host=self.host, port=self.port) prot_fac = TBinaryProtocol.TBinaryProtocolFactory() server = TNonblockingServer.TNonblockingServer(processor=processor, lsocket=socket, inputProtocolFactory=prot_fac, threads=self.threads) return server
def main(): parser = argparse.ArgumentParser("usage: %prog [options]") parser.add_argument('-b', '--bind', dest='host', metavar='ADDR', help='IP addr or hostname to bind to') parser.add_argument('-p', '--port', dest='port', type=int, metavar='PORT', help='port to bind to') parser.add_argument('-d', '--logdir', dest='logdir', metavar='LOGDIR', default='.', help='log DIR') parser.add_argument('-l', '--loglevel', dest='loglevel', metavar='LOGLEVEL', default='DEBUG', help='log flag') parser.add_argument('--thrift', dest='use_thrift', metavar='THRIFT', default=True, help='use thrift or not') parser.add_argument('--gcfg', dest='gcfg', metavar='GMONDCFG', default='/usr/local/etc/gmond.cfg', help='gmond location') args = parser.parse_args() global logger logger = slogger.get_logger(args.logdir, 'logserver', args.loglevel) if args.use_thrift: from common.thrift_gen.log_record import LogCollector from thrift.transport import TSocket from thrift.protocol import TBinaryProtocol from thrift.server import TNonblockingServer perf_rec_queue = Queue.Queue() handler = LogCollectorHandler(perf_rec_queue=perf_rec_queue) processor = LogCollector.Processor(handler) transport = TSocket.TServerSocket(host=args.host, port=args.port) \ if args.port else TSocket.TServerSocket(unix_socket=args.host) tfactory = TBinaryProtocol.TBinaryProtocolFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TNonblockingServer.TNonblockingServer(processor, transport, tfactory, pfactory) collector = PerfCollector(perf_rec_queue, logger) collector.setDaemon(True) collector.start() cfg_path = args.gcfg interval = 60.0 sender = GMetricSender(collector, logger, interval, cfg_path) \ if cfg_path else PerfSender(collector, logger, interval) sender.setDaemon(True) sender.start() logger.info('Starting the server...') server.serve() logger.info('done.') return set_log_dir(args.logdir) if args.port: log_server = LogRecordTCPSocketReceiver(host=args.host, port=args.port) logger.info("About to start tcp log server with port %s", args.port) else: log_server = LogRecordUnixSocketReceiver(host=args.host) logger.info("About to start unix socket log server" " with socket %s", args.host) log_server.serve_until_stopped() log_server.server_close()
sentence.tokenization = Tokenization(uuid = aug.next(), kind = TokenizationKind.TOKEN_LIST, tokenList = TokenList(tokenList=[]), tokenTaggingList = [], metadata = AnnotationMetadata(timestamp=int(time.time()), tool="nltk")) for i, token in enumerate(nltk.word_tokenize(text)): logging.info("Found token %s", token) sentence.tokenization.tokenList.tokenList.append(Token(tokenIndex=i, text=token)) return communication if __name__ == "__main__": import argparse parser = argparse.ArgumentParser() parser.add_argument("-p", "--port", dest="port", type=int, default=9090) options = parser.parse_args() logging.basicConfig(level=logging.INFO) handler = CommunicationHandler() processor = Annotator.Processor(handler) transport = TSocket.TServerSocket(port=options.port) ipfactory = TCompactProtocol.TCompactProtocolFactory() opfactory = TCompactProtocol.TCompactProtocolFactory() server = TNonblockingServer.TNonblockingServer(processor, transport, ipfactory, opfactory) logging.info('Starting the server...') server.serve()
def __create_server(processor, ip, port): transport = TSocket.TServerSocket(ip, port) pfactory = TCompactProtocol.TCompactProtocolFactory() return TNonblockingServer.TNonblockingServer(processor, transport, pfactory)
def main(): op = optparse.OptionParser(usage='%prog [options]', add_help_option=False) op.add_option('-p', '--port', action='store', type='int', dest='port', default=1234, help='The server port') op.add_option('-s', '--servertype', action='store', type='string', dest='servertype', default='TGeventServer', help='Type name of server') op.add_option('-w', '--num_workers', action='store', type='int', dest='workers', default=4, help='Number of worker processes') op.add_option('-Q', '--max_queue_size', action='store', type='int', dest='max_queue_size', default=0, help='Max queue size, passed to TNonblockingServer') op.add_option('-h', '--header', action='store_true', help='Use the generated ContextIface') op.add_option('-?', '--help', action='help', help='Show this help message and exit') (options, args) = op.parse_args() if args: op.error('trailing arguments: ' + ' '.join(args)) handler = LoadHandler() if options.servertype == 'TGeventServer': # only import TGeventServer when necessary. TGeventServer calls # monkey_patch, which breaks other servers from apache.thrift.test.sync_load_handler import GeventLoadHandler from thrift.server import TGeventServer handler = GeventLoadHandler() processor = LoadTest.Processor(handler) if options.header: pfactory = THeaderProtocolFactory(True, \ [THeaderTransport.HEADERS_CLIENT_TYPE, THeaderTransport.FRAMED_DEPRECATED, THeaderTransport.UNFRAMED_DEPRECATED, THeaderTransport.HTTP_CLIENT_TYPE]) if options.servertype == 'TNonblockingServer': print 'Header transport, backwards compatible with framed' else: print 'Header transport, backwards compatible with ' + \ 'unframed, framed, http' else: if options.servertype == 'TNonblockingServer': print 'Framed transport' else: print 'Unframed transport' pfactory = TBinaryProtocolAcceleratedFactory() transport = TSocket.TServerSocket(options.port) tfactory = TTransport.TBufferedTransportFactory() if options.servertype == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, pfactory, maxQueueSize=options.max_queue_size) elif options.servertype == "TProcessPoolServer": server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) print 'Worker processes: ' + str(options.workers) server.setNumWorkers(options.workers) elif options.servertype == "TGeventServer": print 'Worker processes: ' + str(options.workers) # Gevent makes its own server transport. server = TGeventServer.TGeventServer(options.port, processor, None, tfactory, pfactory) server.setNumWorkers(options.workers) else: ServerClass = getattr(TServer, options.servertype) server = ServerClass(processor, transport, tfactory, pfactory) print 'Serving ' + options.servertype + \ ' requests on port %d...' % (options.port,) server.serve()
def main(): op = optparse.OptionParser(usage='%prog [options]', add_help_option=False) op.add_option('-p', '--port', action='store', type='int', dest='port', default=1234, help='The server port') op.add_option('-s', '--servertype', action='store', type='string', dest='servertype', default='TNonblockingServer', help='Type name of server') op.add_option('-w', '--num_workers', action='store', type='int', dest='workers', default=4, help='Number of worker processes/threads') op.add_option('-Q', '--max_queue_size', action='store', type='int', dest='max_queue_size', default=0, help='Max queue size, passed to TNonblockingServer') op.add_option('-h', '--header', action='store_true', help='Use the generated ContextIface') op.add_option('-?', '--help', action='help', help='Show this help message and exit') (options, args) = op.parse_args() if args: op.error('trailing arguments: ' + ' '.join(args)) handler = LoadHandler() processor = LoadTest.Processor(handler) if options.header: pfactory = THeaderProtocolFactory(True, [ CLIENT_TYPE.HEADER, CLIENT_TYPE.FRAMED_DEPRECATED, CLIENT_TYPE.UNFRAMED_DEPRECATED, CLIENT_TYPE.HTTP_SERVER ]) if options.servertype == 'TCppServer': print('C++ ThriftServer, Header transport, backwards compatible ' 'with all other types') elif options.servertype == 'TNonblockingServer': print('Header transport, backwards compatible with framed') else: print('Header transport, backwards compatible with ' + 'unframed, framed, http') else: if options.servertype == 'TCppServer': if not options.header: op.error('TCppServer cannot be used without header') elif options.servertype == 'TNonblockingServer': print('Framed transport') else: print('Unframed transport') pfactory = TBinaryProtocolAcceleratedFactory() if options.servertype == 'TCppServer': server = TCppServer.TCppServer(processor) server.setPort(options.port) print('Worker threads: ' + str(options.workers)) server.setNumIOWorkerThreads(options.workers) else: transport = TSocket.TServerSocket(options.port) tfactory = TTransport.TBufferedTransportFactory() if options.servertype == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, pfactory, maxQueueSize=options.max_queue_size) elif options.servertype == "TProcessPoolServer": server = TProcessPoolServer.TProcessPoolServer( processor, transport, tfactory, pfactory) print('Worker processes: ' + str(options.workers)) server.setNumWorkers(options.workers) else: ServerClass = getattr(TServer, options.servertype) server = ServerClass(processor, transport, tfactory, pfactory) print('Serving ' + options.servertype + ' requests on port %d...' % (options.port, )) server.serve()
def __init__(self): handler = Handler() processor = TestServer.Processor(handler) transport = TSocket.TServerSocket("127.0.0.1", 30030) self.server = TNonblockingServer.TNonblockingServer( processor, transport)
except: print("Could not load THttpServer") raise else: if options.ssl: cert_path = 'thrift/test/py/test_cert.pem' transport = TSSLSocket.TSSLServerSocket(options.port, certfile=cert_path) else: transport = TSocket.TServerSocket(options.port) tfactory = TTransport.TBufferedTransportFactory() server_class_name = args[0] if args[0] == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( handler, transport, pfactory, readTimeout=options.timeout) elif args[0] == "TProcessPoolServer": server = TProcessPoolServer.TProcessPoolServer( handler, transport, tfactory, pfactory) else: ServerClass = getattr(TServer, server_class_name) server = ServerClass(handler, transport, tfactory, pfactory) if options.header: server.processor.setEventHandler(HeaderEventHandler()) elif options.context: server.processor.setEventHandler(ContextEventHandler()) server.serverEventHandler = event_handler server.serve()
if options.trans == 'buffered': tfactory = TTransport.TBufferedTransportFactory() elif options.trans == 'framed': tfactory = TTransport.TFramedTransportFactory() elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) else: tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib tfactory = TZlibTransport.TZlibTransportFactory() # do server-specific setup here: if server_type == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, inputProtocolFactory=pfactory) elif server_type == "TProcessPoolServer": import signal from thrift.server import TProcessPoolServer server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) server.setNumWorkers(5) def set_alarm(): def clean_shutdown(signum, frame): for worker in server.workers: if options.verbose > 0: print 'Terminating worker: %s' % worker worker.terminate() if options.verbose > 0: print 'Requesting server to stop()'
def testSet(self, thing): return thing def testList(self, thing): return thing def testEnum(self, thing): return thing def testTypedef(self, thing): return thing pfactory = TBinaryProtocol.TBinaryProtocolFactory() handler = TestHandler() processor = ThriftTest.Processor(handler) if sys.argv[1] == "THttpServer": server = THttpServer.THttpServer(processor, ('', 9090), pfactory) else: transport = TSocket.TServerSocket(9090) tfactory = TTransport.TBufferedTransportFactory() if sys.argv[1] == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer(processor, transport) else: ServerClass = getattr(TServer, sys.argv[1]) server = ServerClass(processor, transport, tfactory, pfactory) server.serve()
fh.setLevel(logging.INFO) # create console handler with a higher log level ch = logging.StreamHandler() ch.setLevel(logging.INFO) # handler = PingHandler() # create formatter and add it to the handlers formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) # add the handlers to the logger logger.addHandler(fh) logger.addHandler(ch) handler = movie_service_impl.MovieServiceHandler() processor = MovieService.Processor(handler) # processor = Ping.Processor(handler) transport = TSocket.TServerSocket(host="127.0.0.1", port=9090) t_factory = TBinaryProtocol.TBinaryProtocolFactory() p_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory() server = TNonblockingServer.TNonblockingServer(processor, transport, t_factory, p_factory, threads=100) print 'Starting server' server.serve()
elif args[0] == "TCppServer": server = TCppServer.TCppServer(processor) server.setPort(options.port) else: if options.ssl: cert_path = 'thrift/test/py/test_cert.pem' transport = TSSLSocket.TSSLServerSocket(options.port, certfile=cert_path) else: transport = TSocket.TServerSocket(options.port) tfactory = TTransport.TBufferedTransportFactory() server_class_name = args[0] if args[0] == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, pfactory, readTimeout=options.timeout) elif args[0] == "TProcessPoolServer": server = TProcessPoolServer.TProcessPoolServer( processor, transport, tfactory, pfactory) else: ServerClass = getattr(TServer, server_class_name) server = ServerClass(processor, transport, tfactory, pfactory) if options.header: server.processor.setEventHandler(HeaderEventHandler()) elif options.context: server.processor.setEventHandler(ContextEventHandler()) server.setServerEventHandler(event_handler) server.serve()
return True except smtplib.SMTPException as e: print("send email failed!") print(e) return False if __name__ == "__main__": # 1. 创建 Thrift Server 的 ServeSocket serverSocket = TSocket.TServerSocket(host=host, port=port) # serverSocket = TSocket.TServerSocket(None, port="9090") # 2. 创建 Thrift Server 的 Transport = 帧传输方式 transportFactory = TTransport.TFramedTransportFactory() # 3. 创建 Thrift Server 的 Protocol = 二进制传输协议 protocolFactory = TBinaryProtocol.TBinaryProtocolFactory() # 4. 创建 Thrift Server 提供的处理方法 handler = MessageServiceHandler() # from message.api import MessageService processor = MessageService.Processor(handler) # 5. 创建 Thrift Server, 指明如何处理,监听什么端口,传输方式,传输协议 # thriftServer = TServer.TSimpleServer(processor, # serverSocket, # transportFactory, # protocolFactory) thriftServer = TNonblockingServer.TNonblockingServer( processor, serverSocket, protocolFactory, protocolFactory) # 6. 启动 Thrift Server, 等待客户端的访问 print("Python Thrift Server start ...") thriftServer.serve() print("Python Thrift Server stop ...")