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')
