def loadHandler(self, handler):
processor = CmdbAppManagerService.Processor(handler)
server = TServer.TThreadPoolServer(processor, self.transport,
self.tfactory, self.pfactory)
print 'Starting the server...'
server.serve()
print 'done.'
def main(conf):
# 启动调度器
scheduler = Scheduler(conf)
scheduler.start()
# 启动输入流程
scheduler_server = SchedulerServer(conf, scheduler)
scheduler_server.start()
def signal_handler(signalnum, frame):
conf['log'].info("received a signal:%s" % signalnum)
scheduler_server.stop("stops")
exit(1)
signal.signal(signal.SIGTERM, signal_handler)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGUSR1, lambda a, b: profiling_signal_handler("scheduler", a, b))
try:
handler = ScheduleHandler(scheduler)
processor = SchedulerService.Processor(handler)
transport = TSocket.TServerSocket(port=conf['server']['port'])
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory, daemon=True)
server.setNumThreads(conf['server']['server_thread_num'])
server.serve()
except Exception as e:
log.error("调度器启动失败...")
log.exception(e)
conf['log'].error(str(traceback.format_exc()))
scheduler_server.stop("fail")
scheduler_server.stop("success")
def __init__(self, policy): #, expected_instance_cnt):
self.instance_list = {}
self.ip = wieraCommon.get_public_ip()
self.port = 0
self.policy = policy
self.monitoring_info = {}
# set handler to our implementation
# to avoid any sync issue with portnumber
handler = WieraTieraInstanceHandler(policy, self)
processor = WieraTieraInstanceIface.Processor(handler)
self.transport = TSocket.TServerSocket(None)
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# set server
self.server = TServer.TThreadPoolServer(processor,
self.transport,
tfactory,
pfactory,
daemon=True)
self.port = self.transport.port
#set socket thread 20 min
self.server.setNumThreads(64)
#Thrift Server Start
self.instance_manager_thread = threading.Thread(
target=self.run_forever, args=())
self.instance_manager_thread.daemon = True
self.instance_manager_thread.start()
def start_server_handle(server_name, server_ip, port,
service_inter_module_name, service_inter_class_name,
service_impl_module_name, service_impl_class_name):
""" start thrift server on port
"""
# dynamic generate service impl and inter class
AlgServiceImplClass = getattr(
__import__(service_impl_module_name, globals(), locals(),
[service_impl_class_name]), service_impl_class_name)
AlgServiceProcessorClass = getattr(
__import__(service_inter_module_name, globals(), locals(),
[service_inter_class_name]), service_inter_class_name)
# instantiation class object
alg_service_processor = AlgServiceProcessorClass(AlgServiceImplClass(port))
transport = TSocket.TServerSocket(server_ip, port)
# tfactory = TTransport.TFramedTransportFactory()
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# server = TNonblockingServer(
# alg_service_processor, transport, tfactory, pfactory)
server = TServer.TThreadPoolServer(alg_service_processor, transport,
tfactory, pfactory)
logging.info('Starting the %s server on IP %s port:%s', server_name,
server_ip, port)
server.serve()
def make_server(self):
# 指定端口启动transport
transport = TSocket.TServerSocket(host=self.__host, port=self.__port)
'''
TTransport（传输层），定义数据传输方式，可以为TCP/IP传输，内存共享或者文件共享等）被用作运行时库。
TSocket：阻塞式socker；
TFramedTransport：以frame为单位进行传输，非阻塞式服务中使用；
TFileTransport：以文件形式进行传输；
TMemoryTransport：将内存用于I/O，java实现时内部实际使用了简单的ByteArrayOutputStream；
TZlibTransport：使用zlib进行压缩， 与其他传输方式联合使用，当前无java实现；
'''
tfactory = TTransport.TBufferedTransportFactory()
'''
TProtocol（协议层），定义数据传输格式:
TBinaryProtocol：二进制格式；
TCompactProtocol：压缩格式；
TJSONProtocol：JSON格式；
TSimpleJSONProtocol：提供JSON只写协议, 生成的文件很容易通过脚本语言解析；
TDebugProtocol：使用易懂的可读的文本格式，以便于debug
'''
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
'''
Thrift支持的服务模型:
TSimpleServer：简单的单线程服务模型，常用于测试；
TThreadPoolServer：多线程服务模型，使用标准的阻塞式IO；
TNonblockingServer：多线程服务模型，使用非阻塞式IO（需使用TFramedTransport数据传输方式）；
'''
server = TServer.TThreadPoolServer(multi_processor, transport, tfactory, pfactory)
return server
def create_tserver():
sock = TSocket.TServerSocket()
handler = HelloHandler()
processor = Processor(handler)
server = TServer.TThreadPoolServer(processor, sock, tfactory, pfactory)
return server
def run():
#创建服务器
handler = HelloHandler()
# Processor = Processor(handler)
processor = Processor(handler)
#监听端口
transport = TSocket.TServerSocket("localhost",9234)
#选择传输层
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#选择传输协议
tfactory = TTransport.TBufferedTransportFactory()
#指定格式：服务器、监听端口、传输协议、传输层
server = TServer.TThreadPoolServer(processor,
transport,
tfactory,
pfactory)
#设置服务线程
server.setNumThreads(5)
print("service is running")
server.serve()
def main():
parser = argparse.ArgumentParser(description='TODO')
parser.add_argument('-p',
'--port',
type=int,
required=True,
help="My port")
parser.add_argument('-t',
'--prediction_time',
type=float,
required=True,
help="Amount of time the prediction step should take")
args = parser.parse_args()
port = args.port
handler = WorkerHandler(args.prediction_time, .2, 15)
processor = Worker.Processor(handler)
transport = TSocket.TServerSocket(port=port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
server.setNumThreads(10)
#server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
print "Starting python server..."
server.serve()
print "done!"
def get_server(api, handler, port, **kwargs):
processor = api.Processor(handler)
socket = TSocket.TServerSocket(port=port)
tfactory = kwargs.get('transport') or TTransport.TFramedTransportFactory()
pfactory = kwargs.get('protocol') or TBinaryProtocolAcceleratedFactory()
server = TServer.TThreadPoolServer(processor, socket, tfactory, pfactory)
server.setNumThreads(8)
return server
def run(self):
processor = Processor(self)
transport = TSocket.TServerSocket(self.host, self.port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
print(f'start python server...{self.host}:{self.port}')
server.serve()
def run(self, portNumber = 9090):
handler = Handler()
processor = GraphCRUD.Processor(handler)
transport = TSocket.TServerSocket(port=portNumber)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory)
server.serve()
def _run(self): handler = EasyHadoopHandler() processor = EasyHadoop.Processor(handler) transport = TSocket.TServerSocket(self.host,self.port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) while True: print 'Starting server'+os.linesep server.serve()
def create_server():
sock = TSocket.TServerSocket()
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
handler = HelloHandler()
processor = Processor(handler)
server = TServer.TThreadPoolServer(processor, sock, tfactory, pfactory)
return server
def main(args):
with Main(args, threading.Lock) as service:
control = Control()
addqueue = AddQueue(service)
interface = Interface(addqueue, service)
# Thrift setup
processor = Processor(interface)
transport = ServerSocket(port=conf.getint("thrift", "port"))
server = thriftserver.TThreadPoolServer(processor, transport, daemon=True)
server.setNumThreads(conf.getint("thrift", "threads"))
# threads
addqueue_thread = threading.Thread(target=addqueue.process)
addqueue_thread.daemon = True
service_thread = threading.Thread(target=server.serve)
service_thread.daemon = True
try:
service.init()
log.debug("starting add queue")
addqueue_thread.start()
log.info("starting thrift service")
service_thread.start()
service.flush()
# main loop
while True:
condition = control.sleep()
if condition == control.Condition.Timeout:
service.flush()
elif condition == control.Condition.Terminate:
break
elif condition == control.Condition.Hangup:
log.info("reconfiguring")
service.reconfigure()
elif condition == control.Condition.User1:
if conf.getboolean("debug", "force_cache_rotation", False):
service.flush(force_rotate=True)
finally:
log.info("closing add queue")
addqueue.close()
def __init__(self, filebase, port):
self.processor = RemusNet.Processor(RemusKyoto(filebase))
self.socket = TSocket.TServerSocket(port=port)
self.port = self.socket.port
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
tfactory = TTransport.TBufferedTransportFactory()
self.server = TServer.TThreadPoolServer(self.processor, self.socket,
tfactory, pfactory)
self.t = ServerThread(self.server)
self.t.start()
def run(self):
handler = Handler()
processor = server.Processor(handler)
transport = TSocket.TServerSocket(self.host, self.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)
rpc_server.serve()
def main(decentralized):
handler = CommoServerHandler(decentralized)
processor = CommoServer.Processor(handler)
transport = TSocket.TServerSocket(host='0.0.0.0', port=SERVER_PORT)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
server.setNumThreads(SERVER_THREADS)
logger.info("Starting server!")
server.serve()
def __init__(self, pidfile):
daemon.Daemon.__init__(self, pidfile)
self.handler = MydlpHandler()
self.processor = Mydlp.Processor(self.handler)
self.transport = TSocket.TServerSocket("127.0.0.1", 9090)
self.tfactory = TTransport.TBufferedTransportFactory()
self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
#server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
self.server = TServer.TThreadPoolServer(self.processor, self.transport, self.tfactory, self.pfactory)
def start_server(self):
print("Starting adapter server" + self.r_address.Address + ":" +
str(self.r_address.Port))
processor = MMIAdapter.Processor(
ThriftAdapterImplementation(self.session_data))
transport = TSocket.TServerSocket(host=self.a_address.Address,
port=self.a_address.Port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TCompactProtocol.TCompactProtocolFactory()
#server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
server.setNumThreads(4)
server.serve()
def run(self):
self.handler = Handler(self.config, self.debug)
print('Starting servers...')
self.handler.start_server()
processor = server.Processor(self.handler)
transport = TSocket.TServerSocket(self.host, self.port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
rpc_server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
rpc_server.setNumThreads(NUM_THREAD)
print('Starting the RPC at', self.host, ':', constants.PORT)
rpc_server.serve()
def run():
#创建服务端
handler = MonitorService()
processor = Processor(handler)
#监听端口
transport = TSocket.TServerSocket('localhost', 9999)
#选择传输层
tfactory = TTransport.TBufferedTransportFactory()
#选择传输协议
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#创建服务端
server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
server.setNumThreads(5)
#handler.logger.info('start thrift serve in python')
server.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 run(self):
"""
Starts thrift server in a Daemon
Returns:
"""
self.logger = logging.getLogger(__name__)
config = config_loader.get(sys.argv[2])
handler = WorkerHandler(sys.argv[2], self.rundir)
proc = Worker.Processor(handler)
trans_svr = TSocket.TServerSocket(port=int(sys.argv[3]) +
int(config["port"]["start"]))
trans_fac = TTransport.TFramedTransportFactory()
proto_fac = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadPoolServer(proc, trans_svr, trans_fac,
proto_fac)
self.logger.info("Starting CaffeWorker Daemon")
server.serve()
def _run_applications_server(self, server_port):
# set handler to our implementation
handler = ApplicationToWieraHandler(self)
processor = ApplicationToWieraIface.Processor(handler)
transport = TSocket.TServerSocket(port=server_port)
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# set server
server = TServer.TThreadPoolServer(processor,
transport,
tfactory,
pfactory,
daemon=True)
print '[Wiera] Starting applications server port:' + str(server_port)
server.serve()
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 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 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 run(host=HOST, port=PORT):
try:
# 注意确保模型参数文件存在，若不存在则先运行examples.py中的train方法
model = BayesSpamModel.import_model()
# 线程池
server = TServer.TThreadPoolServer(
MailQueryService.Processor(MailQueryServiceHandler(model)),
# 注意py3的socket tcp通信默认采用tcpv6
TSocket.TServerSocket(host, port),
TTransport.TFramedTransportFactory(),
TCompactProtocol.TCompactProtocolFactory())
server.setNumThreads(3)
server.serve()
except Thrift.TException as e:
logging.exception(repr(e))
def __init__(self, shard_mapping, assigned_shard_id, owner_player_id):
global logger
logger = logging.getLogger("commo-shard-server-%s" % assigned_shard_id)
logger.setLevel('DEBUG')
self.shard_mapping = shard_mapping
my_serverport_str = None
self.my_serverport = None
# others = copy.deepcopy(self.shard_mapping)
others = []
for info in shard_mapping[assigned_shard_id]:
if info.player_id != owner_player_id:
others.append(generate_serverport(info))
else:
self.my_serverport = info
my_serverport_str = generate_serverport(info)
# Set up RAFT with fellow shard leaders
self.watcher = ShardSyncWatcher(my_serverport_str, others)
while not self.watcher.isReady():
time.sleep(0.05)
self.initial_leader = self.watcher._isLeader()
if self.initial_leader:
logger.info('%s is the initial leader for shard id %s' %
(my_serverport_str, assigned_shard_id))
host = self.my_serverport.server
port = self.my_serverport.port
handler = ShardServerHandler(replicated_storage=self.watcher.replicated_game_state,
synced_obj=self.watcher)
processor = CommoServer.Processor(handler)
transport = TSocket.TServerSocket(host=host, port=port + 1000)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
self.server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory)
self.server.setNumThreads(SERVER_THREADS)
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.')
