from message.api import MessageService
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
class MessageServiceHandler:
def sendMobileMessage(self, mobile, message):
print("sendMobileMessage" + mobile + " message:" + message)
return True
def sendEmailMessage(self, email, message):
print("sendEmailMessage email:" + email + " message:" + message)
return True
if __name__ == '__main__':
handler = MessageServiceHandler()
processor = MessageService.Processor(handler)
transport = TSocket.TServerSocket("127.0.0.1", "9090")
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("pthon thrift server start")
server.serve()
print("python thrift server exit")
server.serve()
sys.exit(0)
# set up server transport and transport factory
rel_path = "../keys/server.pem"
abs_key_path = os.path.join(script_dir, rel_path)
host = None
if options.ssl:
from thrift.transport import TSSLSocket
transport = TSSLSocket.TSSLServerSocket(host,
options.port,
certfile=abs_key_path)
else:
transport = TSocket.TServerSocket(host, options.port)
tfactory = TTransport.TBufferedTransportFactory()
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 val in res:
res.remove(val)
else:
res.add(val)
getAtCache.put(key, time, res)
return res
def delKey(self, key):
store.delKey(key)
def delVal(self, key, val):
store.delVal(key, val)
def diff(self, key, time1, time2):
return store.diff(key, time1, time2)
PORT = 8081
handler = HSHandler()
processor = HistoryStore.Processor(handler)
transport = TSocket.TServerSocket(port=PORT)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print "Starting python server..."
server.serve()
print "done!"
def closeFinger(self, key):
for x in range(255, -1, -1):
if belongsTo(self.node_list[x].id, self.curr_node.id,
key) and self.node_list[x].id != self.curr_node.id:
return self.node_list[x]
return self.curr_node
def getNodeSucc(self):
if not self.node_list:
s = SystemException()
s.message = "Finger table does not exist"
raise s
node = self.node_list[0]
return node
if __name__ == '__main__':
handler = FileStoreHandler()
processor = FileStore.Processor(handler)
transport = TSocket.TServerSocket(port=int(sys.argv[1]))
hostname = socket.gethostname()
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)
print('Starting the server...')
server.serve()
self.log = {}
self.client = MongoClient(mongo_server, mongo_port)
self.db = self.client.thrift_kv_db
self.collection = self.db.thrift_kv_collection
def create(self, value):
value = loads(value)
return dumps(self.collection.insert_one(value).inserted_id)
def read(self, obj_id):
return dumps(self.collection.find_one({'_id' : loads(obj_id)}))
def update(self, obj_id, value):
obj_id = loads(obj_id)
value = loads(value)
ret = self.collection.find_one_and_replace({'_id': obj_id}, value,
return_document=ReturnDocument.AFTER)
return dumps(ret)
def delete_doc(self, obj_id):
self.collection.delete_one({'_id': loads(obj_id)})
if __name__ == "__main__":
handler = ThriftKVHandler()
processor = ThriftKVService.Processor(handler)
transport = TSocket.TServerSocket(host='0.0.0.0', port=9090)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
server.serve()
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
import mplayer_handler as m_handler
from lucidaservice import lucida_service
if __name__ == '__main__':
handler = m_handler.MplayerHandler()
processor = lucida_service.Processor(handler)
transport = TSocket.TServerSocket(port=8088)
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
server.serve()
from py.thrift.generated import PersonService
from PersonServiceImpl import PersonServiceImpl
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TCompactProtocol
from thrift.server import TServer
try:
personServiceHandler = PersonServiceImpl()
processor = PersonService.Processor(personServiceHandler)
serverSocket = TSocket.TServerSocket(host="127.0.0.1", port=8899)
transportFactory = TTransport.TFramedTransportFactory()
protocolFactory = TCompactProtocol.TCompactProtocolFactory()
server = TServer.TSimpleServer(processor, serverSocket, transportFactory, protocolFactory)
print("Python Server Started!")
server.serve()
except Thrift.TException as tx:
print('%s' % tx.message)
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
import handler
import conf
import logging
users = []
#set logging
logging.basicConfig(level=logging.INFO)
#read configure file
config = conf.load_config('conf/pyscribe.conf')
handler = handler.LogHandler()
#set parsers
handler.parsers = conf.get_parsers(config.items('parsers'))
processor = scribe.Processor(handler)
transport = TSocket.TServerSocket(config.getint('common', 'port'))
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print 'Starting the server...'
server.serve()
print 'done.'
# Apache Thrift Hello World Python Server
import sys
sys.path.append("gen-py")
from thrift.transport import TSocket
from thrift.server import TServer
from hello import HelloSvc
class HelloHandler:
def hello_func(self):
print("[Server] Handling client request")
return "Hello thrift, from the python server"
handler = HelloHandler()
processor = HelloSvc.Processor(handler)
listeningSocket = TSocket.TServerSocket(port=8585)
server = TServer.TSimpleServer(processor, listeningSocket)
print("[Server] Started")
server.serve()
from rpc import NewsServlet
from rpc.ttypes import *
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
class NewsHandler:
def __init__(self):
pass
def get_news_detail(self):
print "client call %s" % (self.__class__.__name__)
return NewsDetail(1, "title", "content", "news", str(time.time()))
def get_news_list(self):
pass
handler = NewsHandler()
processor = NewsServlet.Processor(handler)
transport = TSocket.TServerSocket(port=12345)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
server.serve()
def get_extraction(self, req):
rsp = ExtRsp()
rsp.text = req.text
rsp.server_info = '47.94.210.236'
#FIXME: 调用模型获取kn
path = cur_path + '/out/1.txt'
sentences = self.get_sentences(req.text)
rsp.kn = self.handle(sentences, path)
return rsp
def set_badcase(self, req):
return BadCaseRsp('ok', '47.94.210.236')
if __name__ == '__main__':
handler = ExtractionHandler()
processor = ExtractionService.Processor(handler)
transport = TSocket.TServerSocket(__HOST, __PORT)
# 传输方式，使用buffer
tfactory = TTransport.TBufferedTransportFactory()
# 传输的数据类型：二进制
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# 创建一个thrift 服务
rpcServer = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print('Starting the rpc server at', __HOST, ':', __PORT)
rpcServer.serve()
print('done')
# -*- coding:utf-8 -*-
from thrift import Thrift
from py.thrift import PersonService
from thrift.transport import TTransport
from thrift.transport import TSocket
from thrift.protocol import TCompactProtocol
from thrift.server import TServer
from PersonServiceImpl import PsersonServiceImpl
try:
personHandler = PsersonServiceImpl()
processor = PersonService.Processor(personHandler)
ss = TSocket.TServerSocket(port=8800, host="localhost")
transFactory = TTransport.TFramedTransportFactory()
protocolFactory = TCompactProtocol.TCompactProtocolFactory()
server = TServer.TSimpleServer(processor, ss, transFactory,
protocolFactory)
server.serve()
except Thrift.TException as e:
pass
# Apache Thrift Frame Layer Network Transport Server in Python
from thrift.transport import TSocket
from thrift.transport import TTransport
acceptor = TSocket.TServerSocket(port=9090)
acceptor.listen();
print("[Server] listening on port 9090")
while (True):
trans_ep = acceptor.accept();
trans = TTransport.TFramedTransport(trans_ep)
data = trans.read(1024*8)
print("[Server] handling request: %s" % (data))
trans.write("Hello Thrift!");
trans.flush()
trans.close()
if data[:4] == "STOP":
break
print("[Server] exiting")
acceptor.close()
def sendEmailMessage(self, email, message):
print("sendEmailMessage, email:" + email + ", message:" + message)
messageObj = MIMEText(message, "plain", "utf-8")
messageObj['From'] = sender
messageObj['To'] = email
messageObj['Subject'] = Header('709小骚骚代码测试邮件，勿慌', 'utf-8')
try:
smtpObj = smtplib.SMTP('smtp.163.com')
smtpObj.login(sender, authCode)
smtpObj.sendmail(sender, [email], messageObj.as_string())
print("send mail success")
return True
except smtplib.SMTPException:
print("send mail failed!")
return False
if __name__ == '__main__':
handler = MessageServiceHandler()
processor = MessageService.Processor(handler)
# transport = TSocket.TServerSocket(host="127.0.0.1", port = 9090)
transport = TSocket.TServerSocket(host=None, port=9090)
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("python thrift server start")
server.serve()
print("python thrift server exit")
class MyTestHandler:
def __init__(self):
self.log = {}
def helloThrift(self):
print "Hello Thrift!"
def studyThrift(self):
print "I'm studying Thrift!"
return "I'm studying Thrift from " + socket.gethostbyname(
socket.gethostname())
def sayMsg(self, msg):
print "sayMsg(" + msg + ")"
return "say " + msg + " from " + socket.gethostbyname(
socket.gethostname())
handler = MyTestHandler()
processor = MyTest.Processor(handler)
transport = TSocket.TServerSocket('127.0.0.1', 3333)
# 选择传输层
tfactory = TTransport.TBufferedTransportFactory()
# 选择传输协议
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# 创建服务端
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print "Starting python server..."
server.serve()
log = SharedStruct()
log.key = logid
log.value = '%d' % (val)
self.log[logid] = log
return val
def getStruct(self, key):
print 'getStruct(%d)' % (key)
return self.log[key]
def zip(self):
print 'zip()'
handler = CalculatorHandler()
processor = Calculator.Processor(handler)
transport = TSocket.TServerSocket(host='localhost', 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.'
msgObj['Subject'] = Header('LeedCode Team Email', 'utf-8')
# Setup smtp server and send out email
# smtpserver = smtplib.SMTP_SSL("smtp.gmail.com", 465)
# smtpserver.ehlo()
# smtpserver.login(gmail_user, gmail_password)
# smtpserver.sendmail(from_address, email, mail.as_string())
# smtpserver.quit()
try:
smtp = smtplib.SMTP('smtp.gmail.com')
smtp.login(gmail_user, gmail_password)
smtp.sendmail(from_address, [email], msgObj.as_string())
print("Send email succeed!")
return True
except smtplib.SMTPException as e:
print("Send email failed! Error: " + e)
return False
if __name__ == '__main__':
port = 9090
handler = MSGServiceHandler()
processor = MSGService.Processor(handler)
transport = TSocket.TServerSocket(None, port)
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("python thrift server start at :%d" % port)
server.serve()
print("python thrift server exit")
EntityMentionSet(uuid=aug.next(),
metadata=AnnotationMetadata(timestamp=int(
time.time()),
tool="nltk"),
mentionList=sum(entities.values(), [])))
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)
tfactory = TTransport.TBufferedTransportFactory()
ipfactory = TCompactProtocol.TCompactProtocolFactory()
opfactory = TCompactProtocol.TCompactProtocolFactory()
server = TNonblockingServer.TNonblockingServer(processor, transport,
ipfactory, opfactory)
logging.info('Starting the server...')
server.serve()
if i.id > self.NodeID and i.id <= key:
t = TSocket.TSocket(i.ip, i.port)
t = TTransport.TBufferedTransport(t)
p = TBinaryProtocol.TBinaryProtocol(t)
c = FileStore.Client(p)
t.open()
k = c.findPred(key)
t.close()
return k
raise SystemException("Find Pred Error - Cannot find pred 2")
# NodeID getNodeSucc()
# throws (1: SystemException systemException),
def getNodeSucc(self):
if not len(self.finger_table):
raise SystemException("Get Node Succ Error - Finger table is missing")
return self.finger_table[0]
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
handler = ChordHandler()
processor = FileStore.Processor(handler)
transport = TSocket.TServerSocket(port=handler.port_num)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print('Starting the server...')
server.serve()
print('done.')
def create_server():
handler = WeatherPiThriftHandler()
return TServer.TSimpleServer(GenericPiThriftService.Processor(handler),
TSocket.TServerSocket(port=port),
TTransport.TBufferedTransportFactory(),
TBinaryProtocol.TBinaryProtocolFactory())
def __init__(self, processor, handler, config):
self._logger = logging.getLogger(__name__)
self._section_name = utils.get_module(__name__)
self._server = None
self._service_name = config.get(self._section_name,
"service",
required=True)
self._port = config.getint(self._section_name, "port", required=True)
self._zk_connect_str = config.get(self._section_name,
"zk_connect_str",
required=True)
self._auth_user = config.get(self._section_name,
"auth_user",
required=True)
self._auth_password = config.get(self._section_name,
"auth_password",
required=True)
self._monitor = config.getboolean(self._section_name,
"monitor",
default=settings.SERVICE_MONITOR)
self._c_module_serialize = config.getboolean(
self._section_name,
"c_module_serialize",
default=settings.USE_C_MODULE_SERIALIZE)
self._server_name = config.get(self._section_name, "name")
self._owner = config.get(self._section_name, "owner")
hosts = "%s/%s" % (self._zk_connect_str,
settings.DEFAULT_ZK_NAMESPACE_ROOT)
self._server_path = "%s/%s" % (self._service_name,
settings.DEFAULT_ZK_NAMESPACE_SERVERS)
self._statistic_path = "%s/%s/%s" % (
self._service_name, settings.DEFAULT_ZK_NAMESPACE_STATISTICS,
settings.DEFAULT_ZK_NAMESPACE_SERVERS)
# create zk acl
self._acls = []
self._acls.append(
make_digest_acl(self._auth_user, self._auth_password, all=True))
self._acls.append(make_acl("world", "anyone", read=True))
# create zk_client
self._zkclient = prpcZKClientManager.make(hosts, config, "server")
self._zkclient.add_auth(
"digest", "%s:%s" % (self._auth_user, self._auth_password))
# create zkpath
if not self._zkclient.exists(self._service_name):
self._zkclient.create(self._service_name, makepath=True)
if not self._zkclient.exists(self._server_path):
self._zkclient.create(self._server_path, acl=self._acls)
if not self._zkclient.exists(self._statistic_path):
self._zkclient.create(self._statistic_path, makepath=True)
self.transport = TSocket.TServerSocket(port=self._port)
self.tfactory = TTransport.TBufferedTransportFactory()
if self._monitor:
self._collector = StatisticsCollector(self._zkclient,
config,
is_server=True)
self._processor = self._statistics_wrapper(processor)(handler)
else:
self._processor = processor(handler)
if self._c_module_serialize:
self.pfactory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
else:
self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()
thrift_client.py
"""
import socket
import sys
from inference import Inference
from inference.ttypes import *
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
class InferenceHandler:
def sendPhoto(self, picture):
ret = [0., 0., 0., 0., 0., 0.]
return ret
handler = InferenceHandler()
processor = Inference.Processor(handler)
transport = TSocket.TServerSocket("localhost", 9090)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("Starting thrift server in python...")
server.serve()
print("done!")
def say(self, word):
print word
if __name__ == '__main__':
try:
parser = argparse.ArgumentParser(
description='Durable File Service Participant.')
parser.add_argument(dest='port', help='Port')
parser.add_argument(dest='filename', help='Input File')
args = parser.parse_args()
port = args.port
coorFile = args.filename
handler = TestCoordinatorHandler()
processor = TestCoordinator.Processor(handler)
tsocket = TSocket.TServerSocket('0.0.0.0', args.port)
transport = TTransport.TBufferedTransportFactory()
protocol = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadedServer(processor, tsocket, transport,
protocol)
host = socket.gethostname()
host += '.cs.binghamton.edu' if host.startswith('remote') else ''
print('TestCoordinator server running on ' + host + ':' + args.port)
server.serve()
except Thrift.TException as tx:
print('%s' % (tx.message))
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)
elif options.servertype == "TCppServer":
server = TCppServer.TCppServer(processor)
server.setPort(options.port)
else:
ServerClass = getattr(TServer, options.servertype)
server = ServerClass(processor, transport, tfactory, pfactory)
print 'Serving ' + options.servertype + \
' requests on port %d...' % (options.port,)
server.serve()
log.value = '%d' % (val)
self.log[logid] = log
return val
def getStruct(self, key):
print 'getStruct(%d)' % (key)
return self.log[key]
def zip(self):
print 'zip()'
handler = CalculatorHandler()
processor = Calculator.Processor(handler)
transport = TSocket.TServerSocket(port=9090)
tfactory = TBinaryProtocol.TBinaryProtocolFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
port = 9090
server = TNonblockingServer.TNonblockingServer(processor, transport, tfactory, pfactory)
# log to stdout
log = logging.getLogger()
log.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(threadName)s - %(message)s')
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(1)
ch.setFormatter(formatter)
for i in range(0, len(operands.complexOperand1)):
result.append(operands.complexOperand1[i] + operands.complexOperand2[i])
return result
def multiply(self, operands):
if ( len(operands.complexOperand1) != len(operands.complexOperand2) ):
raise ttypes.InvalidOperation("Los tamaños deben de ser iguales")
return operands.complexOperand1
def subtract(self, operands):
if ( len(operands.complexOperand1) != len(operands.complexOperand2) ):
raise ttypes.InvalidOperation("Los tamaños deben de ser iguales")
result = []
for i in range(0, len(operands.complexOperand1)):
result.append(operands.complexOperand1[i] - operands.complexOperand2[i])
return result
if __name__ == "__main__":
handler = CalculadoraHandler()
processor = CalculatorComplex.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)
print("iniciando servidor complejo...")
server.serve()
print("fin")
arr.append(
numpy.random.choice(numpy.arange(0, 10),
p=[
0.05, 0.15, 0.05, 0.15, 0.05, 0.15,
0.05, 0.15, 0.05, 0.15
]))
return arr
def calculateStats(self, numbers):
print('calculateStats()')
ans = StatsStruct()
ans.mean = numpy.mean(numbers)
ans.median = numpy.median(numbers)
ans.variance = numpy.var(numbers)
ans.std_dev = numpy.std(numbers)
return ans
if __name__ == '__main__':
handler = CalculatorHandler()
processor = Calculator.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)
print('Starting the server...')
server.serve()
print('done.')
import sys
sys.path.append("gen-py")
from hello import HelloSvc
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
class HelloHandler:
def hello_func(self):
print("[Server] Handling client request")
return "Hello from the python server"
handler = HelloHandler()
proc = HelloSvc.Processor(handler)
trans_svr = TSocket.TServerSocket(port=9090)
trans_fac = TTransport.TBufferedTransportFactory()
proto_fac = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(proc, trans_svr, trans_fac, proto_fac)
server.serve()
is_ipv6 = '-6' if ':' in server_ip else ''
command = "iperf3 {} -J -t 1 -c {}".format(is_ipv6, server_ip)
client_loop_cnt = 0
while client_loop_cnt < client_retries:
try:
response = self.check_output(command)
break
except Exception:
client_loop_cnt += 1
error_msg = '{} retries to reach iperf3 server {}' \
.format(client_loop_cnt, server_ip)
response = json.dumps({'error': error_msg})
time.sleep(1)
return response
if __name__ == '__main__':
handler = TestServer()
transport = TSocket.TServerSocket(DEFAULT_PORT)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = THeaderProtocol.THeaderProtocolFactory()
server = TServer.TSimpleServer(handler, transport, tfactory, pfactory)
# You could do one of these for a multithreaded server
# server = TServer.TThreadedServer(handler, transport, tfactory, pfactory)
print('Starting the server...')
server.serve()
print('done.')
def main():
arglen = len(sys.argv)
i = 1
#默认端口号
port = 9990
#默认不持久化
store = False
#默认持久化文件
store_file = u"bloom_filter.dat"
#默认错误率
error_rate = 0.001
#默认最大元素数量
element_num = 10000000
try:
while i < arglen:
if sys.argv[i] == "-port" or sys.argv[i] == "-p":
port = int(sys.argv[i + 1])
if port < 1:
raise Exception(u"端口号格式错误")
i += 2
elif sys.argv[i] == "--store":
store = True
i += 1
elif sys.argv[i] == "-file":
store_file = sys.argv[i + 1]
i += 2
elif sys.argv[i] == "--version":
print u"bloom filter server v1.00."
quit(0)
elif sys.argv[i] == "--help":
print u"""\
Usage: python bloomfilterserver.py [options]
布隆过滤器服务器
-port, -p 设置端口号,默认9990
--store 开启持久化功能，默认不开启
-file 持久化文件名，默认bloom_filter_store.data
-error-rate 错误率，默认为0.001
-element-num 元素最大数，默认为10,000,000
--version 查看版本号
--help 查看帮助信息
退出状态：
0 正常
-1 程序出错
-2 参数错误
"""
quit(0)
elif sys.argv[i] == u"-error-rate":
temp_error_rate = float(sys.argv[i + 1])
if 0 < error_rate < 1:
error_rate = temp_error_rate
else:
raise Exception(u"错误率设置错误.")
i += 2
elif sys.argv[i] == u"-element-num":
element_num = int(sys.argv[i + 1])
if element_num < 10000:
raise Exception(u"最大元素数量设置错误。")
i += 2
else:
raise Exception(u"无效的参数:%s" % sys.argv[i])
except Exception as e:
logger.error(u"参数错误,%s." % e.message)
quit(-2)
logger.info(
u"布隆过滤器启动参数,port:%s,store:%s,store_file:%s,element_num:%s,error_rate:%s"
% (port, store, store_file, element_num, error_rate))
handler = BloomFilterServer(error_rate, element_num, store, store_file)
#启动
handler.start()
processor = BloomFilterService.Processor(handler)
hostname = socket.gethostbyname(socket.gethostname())
logger.info(u"service %s running listen on %s:%d" %
(handler.__class__.__name__, hostname, port))
transport = TSocket.TServerSocket(hostname, port)
tfactory = TTransport.TBufferedTransportFactory()
#Protocol
#Protocol用于对数据格式抽象，在rpc调用时序列化请求和响应。
#TProtocol的实现包括：TJSONProtocol，TSimpleJSONProtocol，TBinaryProtocol，TBinaryPotocolAccelerated，TCompactProtocol。
#上面每种类型，都有对应的Factory类，用于创建该类对象。
#pfactory = TBinaryProtocol.TBinaryProtocolFactory()
pfactory = TCompactProtocol.TCompactProtocolFactory()
#server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
server = TServer.TThreadPoolServer(processor, transport, tfactory,
pfactory)
server.setNumThreads(2048)
logger.info(u"BloomFilter server Starting!")
server.serve()
logger.infou(u"BloomFilter server done!")