def main():
ip = "0"
port = 9090
server = make_server(interface_thrift.Suggestion, PredictHandler(), ip,
port)
print("serving...", ip, port)
server.serve()
def jvs_server():
return make_server(
jvs_thrift.JvsService,
JvsService(),
config.JVS_THRIFT_SERVICE['host'],
config.JVS_THRIFT_SERVICE['port'],
)
def main():
parser = argparse.ArgumentParser(
description="Ratchet Thrift Server"
)
parser.add_argument(
'--address',
'-a',
default=ADDRESS,
help='Binding address (%s)' % ADDRESS
)
parser.add_argument(
'--port',
'-p',
default=PORT,
help='Binding port (%s)' % PORT
)
args = parser.parse_args()
ratchet_controller = Ratchet(settings['app:main']['mongo_uri'])
dispatcher = Dispatcher(ratchet_controller)
server = make_server(ratchet_thrift.RatchetStats, dispatcher, args.address, args.port)
logger.info('Starting Thrift RPC Server at %s:%s.' % (args.address, args.port))
server.serve()
def serve(thrift_filename,
service_name,
contract_filename,
host="127.0.0.1",
port=6000,
protocol=Protocol.binary,
transport=Transport.framed):
# Loads both the AST and the thriftpy dynamically generated data
ast = ptcdt.thrift_parser.MappedAST.from_file(thrift_filename)
thriftpy_module = thriftpy.load(thrift_filename,
module_name=service_name + "_thrift")
contract = ptcdt.contracts.parse_contract(contract_filename)
# Builds the delegate class which will have all the methods to handle the requests
# The delegate will have the methods dynamically added into them, which actually point
# to methods in a new instance of FunctionDelegate objects
Delegate = build_delegate(
_ServiceExecutionContext(ast, thriftpy_module, contract, service_name))
# Builds the server and starts serving requests
server = make_server(service=getattr(thriftpy_module, service_name),
handler=Delegate(),
host=host,
port=port,
proto_factory=_build_protocol_factory(protocol),
trans_factory=_build_transport_factory(transport))
server.serve()
def run_server(self, local_server, port):
server = make_server(pepi_thrift.CameraServer, local_server,
'127.0.0.1', port)
t = threading.Thread(target=server.serve)
t.daemon = True
t.start()
return None
def main():
server = make_server(calc_thrift.Calculator, Dispatcher(),
'127.0.0.1', 6000,
proto_factory=TCyBinaryProtocolFactory(),
trans_factory=TCyBufferedTransportFactory())
print("serving...")
server.serve()
def ps_job(ps_id, cluster_spec, dim):
signal.signal(signal.SIGINT, soft_exit)
ping_thrift = thriftpy.load("ping.thrift", module_name="ping_thrift")
handler = Dispatcher(dim)
server = make_server(ping_thrift.PingService, handler, '127.0.0.1', 6000)
print "start Server(%s:%d)" % ('127.0.0.1', 6000)
server.serve()
def mk_server(self):
server = make_server(addressbook.AddressBookService, Dispatcher(),
host="localhost", port=self.PORT,
proto_factory=self.PROTOCOL_FACTORY,
trans_factory=self.TRANSPORT_FACTORY)
p = multiprocessing.Process(target=server.serve)
return p
def main():
server = make_server(calc.Calculator,
Dispatcher(),
'127.0.0.1',
6000,
proto_factory=TCyBinaryProtocolFactory())
print("serving...")
server.serve()
def main():
server = make_server(tutorial.Calculator,
CalculatorHandler(),
'127.0.0.1',
6000,
proto_factory=TCyBinaryProtocolFactory())
print("serving...")
server.serve()
def main():
server = make_server(calc_thrift.Calculator,
Dispatcher(),
'127.0.0.1',
6000,
proto_factory=TCyBinaryProtocolFactory(),
trans_factory=TCyBufferedTransportFactory())
print("serving...")
server.serve()
def mk_server(self):
server = make_server(addressbook.AddressBookService,
Dispatcher(),
host="localhost",
port=self.PORT,
proto_factory=self.PROTOCOL_FACTORY,
trans_factory=self.TRANSPORT_FACTORY)
p = multiprocessing.Process(target=server.serve)
return p
def serve(port, server='0.0.0.0'):
"""
Run as a thrift service (interpreter)
Args:
port (int): the port to listen on
server (str): ip to bind to (default: 0.0.0.0)
"""
server = make_server(lang_thrift.CodeExecutor, Dispatcher(), server, port)
server.serve()
def init_receiver(ip, port, requestHandler):
if not os.path.exists("weightsync.thrift"):
f = _get_thrift_file()
weightsync_thrift = thriftpy.load(f.name, module_name="weightsync_thrift")
f.close()
else:
weightsync_thrift = thriftpy.load("weightsync.thrift", module_name="weightsync_thrift")
receiver = make_server(weightsync_thrift.WeightForward, requestHandler, ip, port)
receiver.trans.client_timeout = None
return receiver
def init_server(ip, port, requestHandler):
if not os.path.exists("weightsync.thrift"):
f = _get_thrift_file()
weightsync_thrift = thriftpy.load(f.name,
module_name="weightsync_thrift")
f.close()
else:
weightsync_thrift = thriftpy.load("weightsync.thrift",
module_name="weightsync_thrift")
server = make_server(weightsync_thrift.WeightSync, requestHandler, ip,
port)
return server
def ssl_server(request):
ssl_server = make_server(addressbook.AddressBookService, Dispatcher(),
host='localhost', port=SSL_PORT,
certfile="ssl/server.pem")
ps = multiprocessing.Process(target=ssl_server.serve)
ps.start()
time.sleep(0.1)
def fin():
if ps.is_alive():
ps.terminate()
request.addfinalizer(fin)
def ssl_server(request):
ssl_server = make_server(addressbook.AddressBookService, Dispatcher(),
host='localhost', port=SSL_PORT,
certfile="ssl/server.pem")
ps = multiprocessing.Process(target=ssl_server.serve)
ps.start()
time.sleep(0.1)
def fin():
if ps.is_alive():
ps.terminate()
request.addfinalizer(fin)
def serve_forever(runtime, port, client):
try:
api_details = import_module(runtime.entrypoint)
r = client.post("http://okapi-engine:5000/okapi/service/v1/%s/%s/spec" % (runtime.service_name, runtime.service_version), json = api_details)
logging.debug("post service spec status: %s" % r.status_code)
except:
traceback.print_exc()
try:
logging.info("start to serve on port %s" % port)
server = make_server(okapi_thrift.InvokeService, Dispatcher(), '0.0.0.0', port, trans_factory=TFramedTransportFactory())
server.serve()
except Exception as e:
traceback.print_exc()
sys.exit(2) # serve fails (e.g. port already used) or serve exited (e.g. user press CTRL+C)
def __init__(self):
# We need to run a FrontendService server, even though it does nothing in
# practice
fes = make_server(sparrow_service_thrift.FrontendService,
FLAGS.sparrow_frontend_host, FLAGS.sparrow_frontend_port,
trans_factory=tf)
self.scheduler_client = make_client(sparrow_service_thrift.SchedulerService,
FLAGS.sparrow_scheduler_host,
FLAGS.sparrow_scheduler_port,
trans_factory=tf)
self.scheduler_client.registerFrontend("clusterMixApp",
FLAGS.sparrow_frontend_host + ":" +
str(FLAGS.sparrow_frontend_port))
def server(request):
server = make_server(addressbook.AddressBookService, Dispatcher(),
unix_socket="./thriftpy_test.sock")
ps = multiprocessing.Process(target=server.serve)
ps.start()
time.sleep(0.1)
def fin():
if ps.is_alive():
ps.terminate()
try:
os.remove("./thriftpy_test.sock")
except IOError:
pass
request.addfinalizer(fin)
def server(request):
server = make_server(addressbook.AddressBookService, Dispatcher(),
unix_socket=unix_sock)
ps = multiprocessing.Process(target=server.serve)
ps.start()
time.sleep(0.1)
def fin():
if ps.is_alive():
ps.terminate()
try:
os.remove(unix_sock)
except IOError:
pass
request.addfinalizer(fin)
def __init__(self, metadata: MetadataProvider, pubsub: PubSubProvider,
db: DbProvider, cv: CvProvider, media: MediaProvider,
apiv3: ApiV3Provider):
logging.info("Creating gdcv thrift handler...")
gdcv_thrift = thriftpy.load(
'if/gdcv.thrift', module_name='gdcv_thrift')
dispatch = FrcRealtimeScoringServiceHandler(
version=self.VERSION,
thrift=gdcv_thrift,
metadata=metadata,
pubsub=pubsub,
db=db,
cv=cv,
media=media,
apiv3=apiv3,
)
self.server = make_server(
gdcv_thrift.FrcRealtimeScoringService,
dispatch,
self.BIND_ADDR,
self.BIND_PORT
)
def do_serve(host, port):
print "Starting thrift server on %s:%s..." % (host, port)
try:
server = make_server(
tracelogs_thrift.TraceLogService,
TracesThriftServerController(module=tracelogs_thrift),
host, port,
proto_factory=TCyBinaryProtocolFactory(),
trans_factory=TCyBufferedTransportFactory()
)
server.serve()
except thriftpy.thrift.TException as ex:
logger.error('Thrift error: %s' % ex.message)
except socket_error as sex:
logger.error('Network error: %s' % sex)
except Exception as ex:
logger.error('Application error: %s' % ex)
raise
def main():
server = make_server(
tutorial.Calculator, CalculatorHandler(), '127.0.0.1', 6000,
proto_factory=TCyBinaryProtocolFactory())
print("serving...")
server.serve()
def main_pong():
# 定义监听的端口和服务
server = make_server(pp_thrift.PingService, Dispatcher(), '127.0.0.1', 24680)
print("serving...")
server.serve()
def start_trade_server(thrift_file="traderpc.thrift"):
trade_thrift = thriftpy.load(thrift_file, module_name="trade_thrift")
print('trade server running...')
server = make_server(trade_thrift.TradeRpcService, TradeServer(), '0.0.0.0', 24680, client_timeout=30000)
server.serve()
print('trade server stopped')
def listen():
server = make_server(enqueue_thrift.RPC,
QueueHandler(), master_ip, master_port)
server.serve()
def main():
server = make_server(tutorial_thrift.Calculator, CalculatorHandler(),
'127.0.0.1', 6000)
print("serving...")
server.serve()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import thriftpy
from thriftpy.rpc import make_server
import os
class MyRPC(object):
# 提供调用的方法
def print_fun(self,name):
str = "Hello " + name
return str
if __name__ == "__main__":
file_path = os.path.abspath("../conf/simple.thrift")
# 加载注册文件
simple_thrift = thriftpy.load(file_path, module_name="simple_thrift")
server = make_server(simple_thrift.RPCTest, MyRPC(), '192.168.1.105', 6000)
print "Thriftpy listening 6000......"
server.serve()
def server_start(conf_path, server_ip, server_port):
# 加载注册文件
file_thrift = thriftpy.load(conf_path, module_name="file_thrift")
server = make_server(file_thrift.FileRPC, MyFileRPC(), server_ip, server_port)
print "Thriftpy listening " + str(server_port) + "......"
server.serve()
def fun_rpc_server(args):
print('fun_rpc_server start!')
print(ip, port)
server = make_server(endpoint_service.endpointControl, Dispatcher(), ip,
port)
server.serve()
from open.settings import BASE_DIR
import thriftpy
from thriftpy.rpc import make_server
import os
import logging
ZK_SMARTSYS_ONLINE = ZookeeperHandler(ZK_HOSTS, SMARTSYS_ONLINE)
SERVICES_ONLINE = ZK_SMARTSYS_ONLINE.discover()
THRIFT_ONLINE = thriftpy.load(os.path.join(BASE_DIR, "idl/online.thrift"), module_name="device_online_service_thrift")
class Online(object):
def ping(self):
return "pong"
def get_status(self,device_id):
ret = {'msg': '请求成功', 'data': 'online', 'code': '0'}
return ret
ret = SERVICES_ONLINE
if len(ret) < 1:
# pass
raise Exception("没有可用的服务:%s" % SERVICES_ONLINE)
# 随机方式实现负载均衡
s = ret[randint(0, len(ret) - 1)].split(":")
# server_addr = s[0]
# server_port = int(s[1])
server_addr = "127.0.0.1"
server_port = 6000
server = make_server(THRIFT_ONLINE.Device, Online(), server_addr, server_port)
server.serve()
import thriftpy
from thriftpy.rpc import make_server
import math
sv_thrift = thriftpy.load('service.thrift', module_name='sv_thrift')
class Dispatcher:
def ping(self, x):
return 'Ping~{0}'.format(math.exp(x))
ip = '127.0.0.1'
port = 6666
server = make_server(sv_thrift.Ping, Dispatcher(), ip, port)
server.serve()
def serve(cls, config):
dispatcher = cls()
server = make_server(Allocations, dispatcher, **config['thrift'])
server.serve()
from thriftpy import load
from thriftpy.rpc import make_server
from thriftpy.transport import TFramedTransportFactory
echo_thrift = load("/app/sh/echo.thrift", module_name="echo_thrift")
class echoHandler(object):
def echo(self, msg):
return msg.text
make_server(
service=echo_thrift.Echo,
handler=echoHandler(),
host="127.0.0.1",
port=9999,
trans_factory=TFramedTransportFactory(),
).serve()
def main():
server = make_server(calc.Calculator, Dispatcher(), '127.0.0.1', 6000,
proto_factory=TCyBinaryProtocolFactory())
print("serving...")
server.serve()
import time
import thriftpy
from thriftpy.rpc import make_server
class Dispatcher(object):
def get_time(self):
return time.ctime()
time_thrift = thriftpy.load('time_service.thrift', module_name='time_thrift')
server = make_server(time_thrift.TimeService, Dispatcher(), '127.0.0.1', 6000)
server.serve()
def listen(port=9090):
server = make_server(dequeue_thrift.RPC, Worker(ip, port), ip, port)
server.serve()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: stdrickforce (Tengyuan Fan)
# Email: <*****@*****.**> <*****@*****.**>
import thriftpy
from thriftpy.rpc import make_server
ping_thrift = thriftpy.load("./ping.thrift", module_name='ping_thrift')
class Dispatcher(object):
def __init__(self):
self.logs = {}
def ping(self):
print("ping request")
def foo(self, v_i16, v_bool, v_i32, v_str, v_list, v_set, v_map, v_st,
v_st_map):
print(v_i16, v_bool, v_i32, v_str, v_list, v_set, v_map, v_st)
for key, val in v_st_map.items():
print(key, val)
server = make_server(ping_thrift.Ping, Dispatcher(), "0.0.0.0", 6000)
print("server is listening on :6000")
server.serve()
"""
pingpong.thrift
---------------
service PingPong {
string ping(),
}
"""
import thriftpy
pingpong_thrift = thriftpy.load("pingpong.thrift", module_name="pingpong_thrift")
from thriftpy.rpc import make_server
class Dispatcher(object):
def ping(self):
return "pong"
server = make_server(pingpong_thrift.PingPong, Dispatcher(), '127.0.0.1', 6000)
server.serve()
def start_server():
server = make_server(thrift_service.Ping, Dispatcher(), 'localhost', 9001)
print('serving..')
server.serve()
# In The Name Of God # ======================================== # [] File Name : server.py # # [] Creation Date : 11-10-2016 # # [] Created By : Parham Alvani ([email protected]) # ======================================= import thriftpy from thriftpy.rpc import make_server watraft_thrift = thriftpy.load("WatRaft.thrift", module_name="watraft_thrift") class Dispatcher: def get(self, key: str): return "Amusse you get the value of %s" % key def put(self, key: str, val: str): return "Ammuse %s is put into %s" % (value, key) def append_entries(self, term: int, leader_id: int, prev_log_index: int, prev_log_temr: int, entries: list, leader_commit_index: int): return "You take this shit seriously" server = make_server(watraft_thrift.WatRaft, Dispatcher(), '127.0.0.1', 6000) server.serve()
def main():
server = make_server(pp_thrift.PingService, Dispatcher(),
'127.0.0.1', 6000)
print("serving...")
server.serve()
def jvs_server():
return make_server(
jvs_thrift.JvsService, JvsService(),
config.JVS_THRIFT_SERVICE['host'],
config.JVS_THRIFT_SERVICE['port'],
)
print(instance)
if (instance is None):
exception = tasks.BaseException()
exception.code = 404
exception.message = 'Task not found'
raise exception
task = TaskHandler.convertInstance(instance)
return task
@staticmethod
def convertInstance(instance):
task = tasks.Task()
task.id = str(instance['_id'])
task.userId = instance['userId']
task.name = instance['name']
task.createdOn = instance['createdOn'].isoformat()
task.done = instance['done']
return task
host = Config.getTaskServiceConfig()['host']
port = Config.getTaskServiceConfig()['port']
print('Server is running on %s port %d' % (host, port))
server = make_server(tasks.Tasks,
TaskHandler(),
host,
port)
server.serve()
import thriftpy
pingpong_thrift = thriftpy.load("pingpong.thrift", module_name="pingpong_thrift")
from thriftpy.rpc import make_server
class Dispatcher(object):
def ping(self):
return "pong"
server = make_server(pingpong_thrift.PingPong, Dispatcher(), '127.0.0.1', 6000)
server.serve()
return json.dumps(to_send)
except fs.FileNotFound as e:
to_send['err'] = str(e)
return json.dumps(to_send)
else:
to_send['err'] = 'An unexpected error occurred'
return json.dumps(to_send)
#Signal handler to ensure that on a termination signal, the file store saves
#the state of the system. Probably don't need this anymore.
def signal_handler(signal, frame):
sys.exit(0) #And now its watch has ended
signal.signal(signal.SIGTERM,
signal_handler) #Really, this is just like signing a will
#Starts the thrift service running on port 6000
#Remember, use 127.0.0.1 and not localhost. We still want to avoid the apocalypse!
server = make_server(link_thrift.Link,
Dispatcher(),
'127.0.0.1',
6000,
proto_factory=TCyBinaryProtocolFactory(),
trans_factory=TCyBufferedTransportFactory())
print("Service activated")
server.serve()
finished = True
import thriftpy
test_thrift = thriftpy.load("benchmarkmessage.thrift",
module_name="test_thrift")
from thriftpy.rpc import make_server
class Dispatcher(object):
def echo(self, message):
return message
server = make_server(test_thrift.Helloworld, Dispatcher(), '127.0.0.1', 6000)
server.serve()
class Dispatcher(object):
def initialize(self, initList):
print 'here'
initList = pickle.loads(initList)
self.models = []
for dim in initList:
self.models.append(LinearModel(dim[0], dim[1], dim[2]))
print self.models
def predict(self, h, id):
id = int(id)
currModel = self.models[id] # by id
h_val = pickle.loads(h)
syn_gradient = currModel.get_syn_gradients(np.mean(h_val, axis=0))
return pickle.dumps(syn_gradient, protocol=0)
def update(self, trueGrad, id):
id = int(id)
currModel = self.models[id]
trueGrad_val = pickle.loads(trueGrad)
# print trueGrad_val
currModel.update_model(trueGrad_val)
server = make_server(linear_thrift.LinearModel, Dispatcher(), '127.0.0.1',
6010)
server.serve()
def main():
server = make_server(pp_thrift.PingService, Dispatcher(), '127.0.0.1',
6000)
print("serving...")
server.serve()
def main():
server = make_server(sleep_thrift.Sleep, Dispatcher(),
'127.0.0.1', 6000)
print("serving...")
server.serve()
def serve():
server = make_server(addressbook.AddressBookService, Dispatcher(),
'127.0.0.1', 8000)
server.serve()
def main():
server = make_server(sleep_thrift.Sleep, Dispatcher(),
'127.0.0.1', 6000)
print("serving...")
server.serve()
