def run(self): handler = Handler() processor = server.Processor(handler) transport = TSocket.TServerSocket(self.host, constants.PORT) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() rpc_server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) rpc_server.setNumThreads(100) print('Starting the rpc at', self.host, ':', constants.PORT) try: rpc_server.serve() except KeyboardInterrupt: pass
def main(server_id, number_of_servers, port=3030): handler_object = Handler(server_id, number_of_servers) processor = GraphOperations.Processor(handler_object) transport = TSocket.TServerSocket(port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) print("Server %s Port: %s" % (server_id, port)) print("The server is ready to go!") server.serve() print("Bye Bye!")
def createNNServer(port): try: print(bcolors.OKBLUE + 'NNServer: trying to create NNServer on port {}'.format(port)) handler = NNCommHandler() processor = nn_thrift.Processor(handler) transport = TSocket.TServerSocket(host=localhost_ip, port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) print('NNServer: server created!' + bcolors.ENDC) return [server, handler] except: print('NNServer: could not create NNServer!' + bcolors.ENDC)
def __init__(self, pidfile): sinaspider.utils.Daemon.__init__(self, pidfile, self.__class__.__name__) self.host = SCHEDULER_CONFIG['addr'] self.port = SCHEDULER_CONFIG['port'] self.handler = SchedulerServiceHandler() processor = scheduler_service.Processor(self.handler) server_transport = TSocket.TServerSocket(self.host, self.port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() TServer.TServer.__init__(self, processor, server_transport, tfactory, pfactory) self._is_alive = False self.timer = sinaspider.utils.RepeatingTimer( SCHEDULER_CONFIG['proxy_interval'], self.handler.update_proxies_callback)
def main(self): self.set_proctitle(self.name) self.set_exit_handler() try: handler = StateServiceHandler(self) processor = StateService.Processor(handler) transport = TSocket.TServerSocket(self.host, self.port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() # In order to accept multiple simultaneous clients, we use TThreadedServer server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) server.serve() except: logger.error("Error while trying to launch TSCA module")
def start(self, config, node): self.handler = QueryHandler(config, node) self.processor = QueryService.Processor(self.handler) self.transport = TSocket.TServerSocket(port=config["service-port"]) self.tfactory = TTransport.TBufferedTransportFactory() self.pfactory = TBinaryProtocol.TBinaryProtocolFactory() self.server = TServer.TSimpleServer(self.processor, self.transport, self.tfactory, self.pfactory) # You could do one of these for a multithreaded server #server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) #server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) self.serv = Servant(self.server) self.serv.start()
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 start_server(): handler = ReportServiceHandler() processor = ReportService.Processor(handler) transport = TSocket.TServerSocket(port=9090) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) # You could do one of these for a multithreaded server # server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) # server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) print('Starting the server...') server.serve() print('done.')
def serve(port, db_path): handler = ThriftVtorHandler(db_path) processor = ThriftVtor.Processor(handler) transport = TSocket.TServerSocket(port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) # You could do one of these for a multithreaded server #server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) #server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) print 'Starting the server...' server.serve() print 'done.'
def start(): t = MyTimer() t.start() t = Thread(target=start_console) t.start() handler = RequestHandler() processor = rpc_interface.Processor(handler) transport = TSocket.TServerSocket(HOST, APPLY_PORT) tfactory = TTransport.TBufferedTransportFactory() pfactory = MyBinaryProtocolFactory() rpcServer = TaskProcessor(processor, transport, tfactory, pfactory) print('Listening for task:', HOST, ':', APPLY_PORT) rpcServer.serve()
def run_server(port, db_uri, db_version_info, callback_event=None): LOG.debug('Starting codechecker server ...') try: engine = database_handler.SQLServer.create_engine(db_uri) LOG.debug('Creating new database session') session = CreateSession(engine) except sqlalchemy.exc.SQLAlchemyError as alch_err: LOG.error(str(alch_err)) sys.exit(1) session.autoflush = False # Autoflush is enabled by default. LOG.debug('Starting thrift server') try: # Start thrift server. handler = CheckerReportHandler(session, True) processor = CheckerReport.Processor(handler) transport = TSocket.TServerSocket(port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory, daemon=True) LOG.info('Waiting for check results on [' + str(port) + ']') if callback_event: callback_event.set() LOG.debug('Starting to serve') server.serve() session.commit() except socket.error as sockerr: LOG.error(str(sockerr)) if sockerr.errno == errno.EADDRINUSE: LOG.error('Checker port ' + str(port) + ' is already used') sys.exit(1) except Exception as err: LOG.error(str(err)) session.commit() sys.exit(1)
def service2(): handler = CodechatHandler() processor = CodechatSyc.Processor(handler) transport = TSocket.TServerSocket(host='127.0.0.1', port=9090) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) # You could do one of these for a multithreaded server ## server = TServer.TThreadedServer( ## processor, transport, tfactory, pfactory) ## server = TServer.TThreadPoolServer( ## processor, transport, tfactory, pfactory) print('Starting the server...') server.serve() print('done.')
def main(): parser = argparse.ArgumentParser() parser.add_argument('--host', type=str, required=True, help='Host on which the server is listening') parser.add_argument('--port', type=int, required=True, help='Port on which the server is listening') parser.add_argument('--fetcher_host', type=str, required=True, help='Host on which the fetcher server is listening') parser.add_argument('--fetcher_port', type=int, required=True, help='Port on which the fetcher server is listening') parser.add_argument('--photos_dir', type=str, required=True, help='Directory to store the processed/derived photos') parser.add_argument('--log_path', type=str, required=True, help='Path to the log file') parser.add_argument('--pidfile_path', type=str, required=True, help='Path for the pidfile') args = parser.parse_args() pidfile.write_pidfile(args.pidfile_path) logging.basicConfig(level=logging.INFO, filename=args.log_path) service_handler = ServiceHandler(args.fetcher_host, args.fetcher_port, args.photos_dir) processor = photo_save_pb.Service.Processor(service_handler) transport = TSocket.TServerSocket(host=args.host, port=args.port) transport_factory = TTransport.TBufferedTransportFactory() protocol_factory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, transport_factory, protocol_factory) server.serve()
def init_thrift_server(self, socket, processor): """ Creates a thrift server that listens in the given socket and uses the given processor """ try: os.unlink(socket) except OSError as oerr: if oerr.errno != errno.ENOENT: raise transport = TSocket.TServerSocket(unix_socket=socket) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory() listener_server = TSimpleServer(self.name, processor, transport, tfactory, pfactory) return listener_server
def main(argv=None): try: # Setup argument parser parser = ArgumentParser(description="Hurdle 3 Example Solution", formatter_class=ArgumentDefaultsHelpFormatter) parser.add_argument( "--host", type=str, default="0.0.0.0", help= "IP address that the solution server will listen for connections on" ) parser.add_argument("--rpc-port", type=int, default=9090, help="Port for RPC connections") parser.add_argument( "--seed", type=int, default=None, help="Random number generator seed to use for repeatable tests") # Process arguments args = parser.parse_args() handler = SolutionHandler(seed=args.seed) processor = Hurdle3Execution.Processor(handler) transport = TSocket.TServerSocket(host=args.host, port=args.rpc_port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) print('Starting the server...') server.serve() except KeyboardInterrupt: ### handle keyboard interrupt ### return 0 except SystemExit: print('done.') return 0
def start_thrift_server(): ################## CVRS STUFF ################## handler = CVRSHandler() handler._set_database('CVRS_local.sqlite3') processor = CVRSServices.CVRSEndpoint.Processor(handler) # transport = TSocket.TServerSocket(host='192.249.3.246', port=8080) transport = TSocket.TServerSocket(host='0.0.0.0', port=8080) # transport = TSocket.TServerSocket(host='0.0.0.0', port=9090) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() # server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) print('Starting thrift server.') server.serve() print('Thrift server started.') return
def start_query_server(host, port, multi_threaded, query_handler): processor = Processor(query_handler) transport = TSocket.TServerSocket(host=host, port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() if multi_threaded: print('Starting a multi-threaded server...') server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) else: print('Starting a single-threaded server...') server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) server.serve() print('done.')
def buildServer(): from thrift.transport import TSocket, TTransport from thrift.server import TServer from thrift.protocol import TBinaryProtocol global rpc_ip, rpc_port, server, semaphoreNum service_handler = BrandSearchHandler() service_processor = BrandSearch.Processor(service_handler) tsocket = TSocket.TServerSocket(rpc_ip, rpc_port) trans_fac = TTransport.TBufferedTransportFactory() protol_fac = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadPoolServer(service_processor, tsocket, trans_fac, protol_fac) server.setNumThreads(semaphoreNum) init_multiprocess() server.serve() print "server ready"
def startService(glocker): mailsHandler = MailsHandler(glocker) processor = MailsService.Processor(mailsHandler) transport = TSocket.TServerSocket(host=constants.MAILS_SERVER_HOST, port=constants.MAILS_PORT) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadedServer(processor, transport, tfactory, pfactory, daemon=True) logger.info("mails server start") server.serve()
def callbackServer(): global port, callbackDefaultPort import socket processor = QueryCallbackService.Processor(callbackHandler) tfactory = TTransport.TBufferedTransportFactory() pfactory = TCompactProtocol.TCompactProtocolFactory() while True: try: transport = TSocket.TServerSocket(port=port) server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) server.serve() except socket.error: port += 1 if port > callbackDefaultPort + 20: raise Exception("Cannot connect to a SociaLite server") else: break
def make_rpc_server(processor, host='localhost', port=9090): transport = TSocket.TServerSocket(host=host, port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() # 只能连接一个客户端 # server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) # You could do one of these for a multithreaded server # 每个客户端启动一个线程用于连接 # server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) # 连接线程池 server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) server.daemon = True #enable ctrl+c to exit the server server.setNumThreads(10) return server
def set_factory(self): if settings.THRIFTSERVER_BUFFERED: self._tfactory = TTransport.TBufferedTransportFactory() if settings.THRIFTSERVER_ZLIB: self._tfactory = TZlibTransport.TZlibTransportFactory() if settings.THRIFTSERVER_FRAMED: self._tfactory = TTransport.TFramedTransportFactory() if settings.THRIFTSERVER_PROTOCOL == Protocol.BINARY: self._pfactory = TBinaryProtocol.TBinaryProtocolFactory() elif settings.THRIFTSERVER_PROTOCOL == Protocol.COMPACT: self._pfactory = TCompactProtocol.TCompactProtocolFactory() elif settings.THRIFTSERVER_PROTOCOL == Protocol.JSON: self._pfactory = TJSONProtocol.TJSONProtocolFactory() else: raise RuntimeError( "invalid configuration for THRIFTSERVER_PROTOCOL: {}".format( settings.THRIFTSERVER_PROTOCOL))
def CREATE_MOTION_SERVER(controller): handler = MotionServer(controller) processor = T_multi_directional_motion_server.Processor(handler) transport = TSocket.TServerSocket(host="127.0.0.1", port=9999) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() #server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) thread = threading.Thread(target=server.serve) thread.daemon = True thread.start() thread.join() # server.serve() # server.stop()
def main(): # 创建服务端 handler = InterfaceHandler() processor = blur_detection.Processor(handler) # 监听端口 transport = TSocket.TServerSocket("0.0.0.0", config.THRIFT_PORT) # 选择传输层 tfactory = TTransport.TBufferedTransportFactory() # 选择传输协议 pfactory = TBinaryProtocol.TBinaryProtocolFactory() # 创建服务端 # server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) # server.setNumThreads(12) server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) server.setNumWorkers(config.THRIFT_NUM_WORKS) print("Starting thrift server in python...") server.serve() 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(): parser = argparse.ArgumentParser(description='TODO') parser.add_argument('-l', '--num_locks', dest='n_locks', required=True, help="Number of mutexes available", type=int) parser.add_argument('-i', '--my_id', type=int, required=True, help="This machine's ID (must be integer)") parser.add_argument('-n', '--nodes', required=True, dest='nodes', nargs='+', help="all nodes in the form ip:port") parser.add_argument('-b', '--broker', required=True, help="broker handler's ip:port") args = parser.parse_args() if len(args.nodes) < 3: print 'We need at least three nodes to run' quit() nodes = Nodes(args.nodes, args.my_id) port = int(args.nodes[args.my_id].split(':')[1]) broker_host, broker_port = args.broker.split(':') broker = BrokerClient(broker_host, int(broker_port)) handler = PaxosHandler(args.n_locks, args.my_id, nodes, 0, broker) processor = Paxos.Processor(handler) transport = TSocket.TServerSocket(port=port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) print "Starting python server..." server.serve() print "done!"
def _run(self): handler = EasyHadoopHandler() processor = EasyHadoop.Processor(handler) transport = TSocket.TServerSocket(self.host, self.port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TForkingServer(processor, transport, tfactory, pfactory) cherrypy.config.update(self.settings) cherrypy.tree.mount(Index(), '/') cherrypy.tree.mount(Node(), '/node') cherrypy.tree.mount(Jmx(), '/jmx') cherrypy.tree.mount(Token(), '/token') #cherrypy.tree.mount(Expect(), '/expect') cherrypy.engine.start() server.serve()
def init(): global confmap, jsonsemc, jsonsemp, weibosemc, weibosemp, jsonhandler, jsonprocessor, \ jsontransport, jsontfactory, jsonpfactory, jsonserver, weibolog, statelog, queueinfolog, isexit isexit = False signal.signal(signal.SIGUSR1, sig_usr1) signal.signal(signal.SIGUSR2, sig_usr2) confmap = json.load(file("config.json")) weibolog = MyLog(confmap['weibologitem'], 0) statelog = MyLog(confmap['statelogitem'], 1) queueinfolog = MyLog(1) ret = weibolog.initFile(confmap['weibologdir'], confmap['weibologprefix']) if ret != 0: print 'weibolog init failed\n' return -1 ret = statelog.initFile(confmap['statelogdir'], confmap['statelogprefix']) if ret != 0: print 'statelog init failed\n' return -1 ret = queueinfolog.initFile(confmap['statelogdir'], confmap['queueinfologprefix']) if ret != 0: print 'queueinfolog init failed\n' return -1 statelog.write('Server start ...\n') jsonsemp = threading.Semaphore(confmap["jsonqueuemax"]) jsonsemc = threading.Semaphore(0) weibosemp = threading.Semaphore(confmap["weiboqueuemax"]) weibosemc = threading.Semaphore(0) jsonhandler = SendJsonHandler() jsonprocessor = SendJson.Processor(jsonhandler) jsontransport = TSocket.TServerSocket(port=9085) jsontfactory = TTransport.TBufferedTransportFactory() jsonpfactory = TBinaryProtocol.TBinaryProtocolFactory() jsonserver = TServer.TSimpleServer(jsonprocessor, jsontransport, jsontfactory, jsonpfactory) return 0
def server(): handler = RedeemCodeHandler() processor = RedeemCode.Processor(handler) transport = TSocket.TServerSocket(host=config.HOST, port=config.PORT) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() thrift_server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) thrift_server.setNumThreads(config.threads) start_log() try: thrift_server.serve() except KeyboardInterrupt: log.info('server done.') os.kill(os.getpid(), signal.SIGTERM) sys.exit(0) log.info('server done.')
def run_master_server(self): """Start thrift token master server and block waiting until it's done. """ assert self._master_handler processor = Processor(self._master_handler) if self._port: transport = TSocket.TServerSocket(port=self._port) else: transport = TSocket.TServerSocket() self._port = transport.port tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) LOG.info('Starting server on host:port %s:%d', self._hostname, self._port) server.serve() LOG.info('server is done')