def __init__ (self, port):
self.transport = TSocket.TSocket('localhost', port)
self.transport = TTransport.TBufferedTransport(self.transport)
protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
self.client = Disambiguation.Client(protocol)
def __init__(self, host, port):
self._socket = TSocket.TSocket(host, port)
self._transport = TTransport.TBufferedTransport(self._socket)
self._protocol = TBinaryProtocol.TBinaryProtocolAccelerated(
self._transport)
super(CassandraClientHelper, self).__init__(self._protocol)
from thrift.protocol import TBinaryProtocol
from thrift.transport import TSocket, TTransport
from thrift.server import TServer
__HOST = '127.0.0.1'
__PORT = '8080'
class empServiceHandler(object):
# 注释
def getEmpByName(self, name):
return ttypes.empModel
def getEmpByeMisNo(self, mis):
return ttypes.empModel
if __name__ == '__main__':
handler = empServiceHandler()
process = empService.Processor(handler)
trans = TSocket.TServerSocket(__HOST, __PORT)
tfact = TTransport.TBufferedTransportFactory()
pfact = TBinaryProtocol.TBinaryProtocolFactory()
rpcserv = TServer.TSimpleServer(process, trans, tfact, pfact)
print('Starting rpc server at ', __PORT, ':', __HOST)
rpcserv.serve()
def pandas_read_dataframe(config: dict, ranges: tuple, columns: list, meta: dict):
if config['table'] is None:
return None
ret = {}
# try:
transport = TSocket.TSocket(config['proxy_host'], config['proxy_port'])
transport = TTransport.TFramedTransport(transport)
protocol = TCompactProtocol.TCompactProtocol(transport)
client = AccumuloProxy.Client(protocol)
transport.open()
login = client.login(config['user'], {'password': config['password']})
auths = client.getUserAuthorizations(login, config['user'])
# there really has to be something, even if its ('', None), meaning entire table range
scan_ranges = [] if ranges is not None else None
if ranges[1] is None:
r = Range(Key(ranges[0]), True, None, True)
scan_ranges.append(r)
log.debug("\t{0}: Row Ranges: {1}-{2}".format(threading.get_ident(), r.start.row, ''))
else:
r = Range(Key(ranges[0]), True, Key(ranges[1]), False)
scan_ranges.append(r)
log.debug("\t{0}: Row Ranges: {1}-{2}".format(threading.get_ident(), r.start.row, r.stop.row))
scan_columns = []
if columns is not None:
for column in columns:
c = ScanColumn(column, None)
scan_columns.append(c)
log.debug("\t{0}: Scan Column: {1}".format(threading.get_ident(), c))
else:
scan_columns = None
log.debug(f"{scan_columns}, {scan_ranges}")
options = BatchScanOptions(auths, scan_ranges, scan_columns, [], None)
cookie = client.createBatchScanner(login, config['table'], options)
count = 0
entries = 0
while client.hasNext(cookie):
for entry in client.nextK(cookie, 1000).results:
log.debug("\t{0}: Read row: {1}, {2}, {3}".format(threading.get_ident(), entry.key,
entry.key.colFamily, entry.value))
entries += 1
if entry.key.row not in ret:
ret[entry.key.row] = {}
count += 1
if entry.key.colFamily not in ret[entry.key.row]:
ret[entry.key.row][entry.key.colFamily] = {}
ret[entry.key.row][entry.key.colFamily][entry.key.colQualifier] = entry.value
'''
except TableNotFoundException:
log.error("Table not found: {0}".format(config['table']))
return pd.DataFrame()
except Exception as err:
log.error("Accumulo client error: {0}".format(err))
return pd.DataFrame()
'''
log.debug("\t{0}: Read: rows {1}, entries {2}".format(threading.get_ident(), count, entries))
return pd.DataFrame().from_dict({(i, j): ret[i][j]
for i in ret.keys()
for j in ret[i].keys()}, orient='index')
from gen import DemoSerivce
from gen.ttypes import DemoObject
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
if __name__ == '__main__':
# Make socket
transport = TSocket.TSocket('127.0.0.1', 10000)
# Buffering is critical. Raw sockets are very slow
transport = TTransport.TBufferedTransport(transport)
# Wrap in a protocol
protocol = TBinaryProtocol.TBinaryProtocol(transport)
# Create a client to use the protocol encoder
client = DemoSerivce.Client(protocol)
# Connect!
transport.open()
ping = client.ping("test")
print ping
demo_obj = client.getObject("xxx", 2)
print '%s\t%d' % (demo_obj.x, demo_obj.y)
# Close!
def start_extension(name="<unknown>",
version="0.0.0",
sdk_version="1.8.0",
min_sdk_version="1.8.0"):
"""Start your extension by communicating with osquery core and starting
a thrift server.
Keyword arguments:
name -- the name of your extension
version -- the version of your extension
sdk_version -- the version of the osquery SDK used to build this extension
min_sdk_version -- the minimum version of the osquery SDK that you can use
"""
args = parse_cli_params()
# Disable logging for the thrift module (can be loud).
logging.getLogger('thrift').addHandler(logging.NullHandler())
client = ExtensionClient(path=args.socket)
if not client.open(args.timeout):
if args.verbose:
message = "Could not open socket %s" % args.socket
raise ExtensionException(
code=1,
message=message,
)
return
ext_manager = ExtensionManager()
# try connecting to the desired osquery core extension manager socket
try:
status = client.extension_manager_client().registerExtension(
info=InternalExtensionInfo(
name=name,
version=version,
sdk_version=sdk_version,
min_sdk_version=min_sdk_version,
),
registry=ext_manager.registry(),
)
except socket.error:
message = "Could not connect to %s" % args.socket
raise ExtensionException(
code=1,
message=message,
)
if status.code is not 0:
raise ExtensionException(
code=1,
message=status.message,
)
# Start a watchdog thread to monitor the osquery process.
rt = threading.Thread(target=start_watcher, args=(client, args.interval))
rt.daemon = True
rt.start()
# start a thrift server listening at the path dictated by the uuid returned
# by the osquery core extension manager
ext_manager.uuid = status.uuid
processor = Processor(ext_manager)
transport = None
if sys.platform == 'win32':
transport = TPipeServer(
pipe_name="{}.{}".format(args.socket, status.uuid))
else:
transport = TSocket.TServerSocket(unix_socket=args.socket + "." +
str(status.uuid))
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
server.serve()
if len(self.tf_idf_dict) == 0:
return ''
sorted_keywords = sorted(self.tf_idf_dict.iteritems(),
key=lambda x: x[1],
reverse=True)
return json.dumps(sorted_keywords[:nums])
except Exception, e:
print e
logging.error(e)
return ''
if __name__ == '__main__':
try:
handler = KwHandler()
processor = kwServer.Processor(handler)
transport = TSocket.TServerSocket(kw_config.IP, kw_config.PORT)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TProcessPoolServer.TProcessPoolServer(processor, transport,
tfactory, pfactory)
print "Starting kw server..."
logging.info("Starting kw server...")
server.serve()
except Exception, e:
print e
logging.error(e)
finally:
print "done!"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'Ryan Guhnguk Ahn'
import sys
from hive import ThriftHive
from hive.ttypes import HiveServerException
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
try:
transport = TSocket.TSocket('localhost', 10000)
transport = TTransport.TBufferedTransport(transport)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
client = ThriftHive.Client(protocol)
transport.open()
client.execute("CREATE TABLE r(a STRING, b INT, c DOUBLE)")
client.execute("LOAD TABLE LOCAL INPATH '/path' INTO TABLE r")
client.execute("SELECT * FROM r")
while (1):
row = client.fetchOne()
if (row == None):
break
print row
client.execute("SELECT * FROM r")
def extract(self, img_dir):
try:
# Convert unicode to ascci
ret = extract_featrues(str(img_dir))
# ret = 'hello'
# print img_dir
print ret
return ret + 'from ' + str(port)
except:
print('error ...')
handler = FeatureExtractorHandler()
processor = FeatureExtractor.Processor(handler)
transport = TSocket.TServerSocket(ip, port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# server = TServer.TThreadPoolServer(processor,transport,tfactory,pfactory)
server = TNonblockingServer.TNonblockingServer(processor,
transport,
pfactory,
threads=1)
# server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
# from twisted.internet import reactor
# from thrift.transport import TTwisted
# reactor.listenTCP(port, TTwisted.ThriftServerFactory(processor=processor,iprot_factory=pfactory))
# reactor.run()
import sys
sys.path.append("gen-py")
from hola import HolaServicio
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
transporte = TSocket.TSocket("localhost", 9090)
transporte = TTransport.TBufferedTransport(transporte)
protocolo = TBinaryProtocol.TBinaryProtocol(transporte)
cliente = HolaServicio.Client(protocolo)
transporte.open()
mensaje = cliente.hola_func()
print("[Cliente] Se recibio %s" % mensaje)
transporte.close()
else:
return None
def createDemo(self, demo):
print "The client invoke method: " + "createDemo."
demoCache[demo.id] = demo
if __name__ == '__main__':
handler = DemoServiceHandler()
# 创建处理器
processor = DemoService.Processor(handler)
# 监听端口
transport = TSocket.TServerSocket("127.0.0.1", "8911")
# 传输方式工厂:TBufferedTransportFactory/TFramedTransportFactory
# 服务端使用什么传输方式，客户端就需要使用什么传输方式
tfactory = TTransport.TFramedTransportFactory()
# 传输协议工厂:TCompactProtocol/TJSONProtocol/TBinaryProtocol
# 服务端使用什么传输协议，客户端就需要使用什么传输协议
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# 创建服务:TSimpleServer/TForkingServer/TThreadedServer/TThreadPoolServer
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print "python thrift server start on 8911"
server.serve()
from py.thrift.generated import PersonService, ttypes
from thrift import Thrift
from PersonServerImpl import PersonServerImpl
from thrift.transport import TTransport
from thrift.transport import TSocket
from thrift.protocol import TCompactProtocol
from thrift.server import TServer
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
try:
PersonServerHandler = PersonServerImpl()
# 处理器
processor = PersonService.Processor()
# 传输通道
serverSocket = TSocket.TServerSocket(port=8899)
# 传输格式
transportFactory = TTransport.TFramedTransportFactory()
# 传输协议
protocolFactory = TCompactProtocol.TCompactProtocolFactory()
# 传输模型
server = TServer.TSimpleServer(processor, serverSocket, transportFactory,
protocolFactory)
server.serve()
except Thrift.TException, ex:
print "%s" % ex.message
def pandas_write_dataframe(config: dict, data: pd.DataFrame, meta: dict):
if config['table'] is None:
log.info("table name cannot be None")
raise ValueError("Table name cannot be None")
tid = config['table']
count = 0
log.info("PANDAS DATAFRAME: \n{0}".format(data))
cf = None
cq = None
if 'rows' in meta:
rows = meta['rows']
if 'cf' in rows:
cf = rows['cf']
if 'cq' in rows:
cq = rows['cq']
try:
# create table if it doesnt exist
create_table(config, tid)
transport = TSocket.TSocket(config['proxy_host'], config['proxy_port'])
transport = TTransport.TFramedTransport(transport)
protocol = TCompactProtocol.TCompactProtocol(transport)
client = AccumuloProxy.Client(protocol)
transport.open()
opt = WriterOptions(maxMemory=1000000, timeoutMs=1000, threads=2)
lgn = client.login(config['user'], {'password': config['password']})
wtr = client.createWriter(lgn, tid, opt)
cells = {}
attributes = []
for rid, row in data.iterrows():
log.debug("Writing row: {0}".format(rid))
family = row[cf] if cf is not None else None
qualifier = row[cq] if cq is not None else None
for col in data.columns:
if col == cf or col == cq:
continue
family = col if family is None else family
qualifier = col if qualifier is None else qualifier
val = json.dumps(row[col], cls=JsonEncode)
vis = ''
if 'vis' in config and config['vis'] is not None:
if col in config['vis']:
vis = str(config['vis'][col])
ts = time.time()
if 'ts' in config and config['ts'] is not None:
if col in config['ts']:
ts = config['ts'][col]
log.info("Writing kv to {0}: ({1} {2}:{3}, {4}), vis={5}".format(tid, rid, family, qualifier, val, vis))
attributes.append(ColumnUpdate(colFamily=str(family),
colQualifier=str(qualifier),
colVisibility=str(vis),
timestamp=int(ts),
value=str(val)))
### Cant just jam these into cells by rid.. need to use rid + cf + cq
# cells[str(rid)] = attributes
cells.append(attributes)
attributes = []
count = count + 1
client.updateAndFlush(lgn, tid, cells)
client.closeWriter(wtr)
transport.close()
except TableNotFoundException:
log.error("Table not found: {0}".format(tid))
except Exception as err:
log.error("Accumulo client error: {0}".format(err))
return count
def open(self):
socket = TSocket.TSocket(self.host, self.port)
self.transport = TTransport.TBufferedTransport(socket)
protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
self.client = Hbase.Client(protocol)
self.transport.open()
from thrift.protocol import TBinaryProtocol
# Add path for local "gen-py/hbase" for the pre-generated module
gen_py_path = os.path.abspath('gen-py')
sys.path.append(gen_py_path)
from hbase import THBaseService
from hbase.ttypes import *
print "Thrift2 Demo"
print "This demo assumes you have a table called \"example\" with a column family called \"family1\""
host = "localhost"
port = 9090
framed = False
socket = TSocket.TSocket(host, port)
if framed:
transport = TTransport.TFramedTransport(socket)
else:
transport = TTransport.TBufferedTransport(socket)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
client = THBaseService.Client(protocol)
transport.open()
table = "example"
put = TPut(row="row1",
columnValues=[
TColumnValue(family="family1",
qualifier="qualifier1",
try:
server = THttpServer.THttpServer(
processor, ('', options.port), pfactory)
except:
print("Could not load THttpServer")
raise
elif args[0] == "TCppServer":
server = TCppServer.TCppServer(processor)
server.setPort(options.port)
else:
if options.ssl:
cert_path = 'thrift/test/py/test_cert.pem'
transport = TSSLSocket.TSSLServerSocket(options.port,
certfile=cert_path)
else:
transport = TSocket.TServerSocket(options.port)
tfactory = TTransport.TBufferedTransportFactory()
server_class_name = args[0]
if args[0] == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(
processor, transport, pfactory,
readTimeout=options.timeout)
elif args[0] == "TProcessPoolServer":
server = TProcessPoolServer.TProcessPoolServer(
processor, transport, tfactory, pfactory)
else:
ServerClass = getattr(TServer, server_class_name)
server = ServerClass(processor, transport, tfactory, pfactory)
def connect():
switchtime = 58
totaltime = 60
p4_client_module = importlib.import_module("p4_pd_rpc." + p4_name)
transport = TSocket.TSocket("localhost", 9090)
bprotocol = TBinaryProtocol.TBinaryProtocol(transport)
p4_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, p4_name)
client = p4_client_module.Client(p4_protocol)
pal_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "pal")
pal_client_module = importlib.import_module(".".join(["pal_rpc", "pal"]))
conn_mgr_client_module = importlib.import_module('.'.join(
['conn_mgr_pd_rpc', 'conn_mgr']))
conn_mgr_protocol = TMultiplexedProtocol.TMultiplexedProtocol(
bprotocol, 'conn_mgr')
conn_mgr = conn_mgr_client_module.Client(conn_mgr_protocol)
transport.open()
pal = pal_client_module.Client(pal_protocol)
dev_id = 0
ports = [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60]
pal.pal_port_del_all(dev_id)
for port in ports:
pal.pal_port_add(dev_id, port, pal_port_speed_t.BF_SPEED_40G,
pal_fec_type_t.BF_FEC_TYP_NONE)
pal.pal_port_enable_all(dev_id)
sess_hdl = conn_mgr.client_init()
dev_tgt = DevTarget_t(0, int(0xFFFF) - 0x10000)
for kv in iphash2port:
match_spec = flowSF_ECMP_t_match_spec_t(ipv4Addr_to_i32(kv[0]), kv[1])
action_spec = flowSF_ECMP_action_spec_t(kv[2])
try:
client.ECMP_t_table_delete_by_match_spec(sess_hdl, dev_tgt,
match_spec)
except:
pass
client.ECMP_t_table_add_with_ECMP(sess_hdl, dev_tgt, match_spec,
action_spec)
for kv in s:
priority = 0
match_spec = flowSF_offset_match_spec_t(kv[0], kv[1])
action_spec = flowSF_os_action_spec_t(kv[2], kv[3])
try:
client.offset_table_delete_by_match_spec(sess_hdl, dev_tgt,
match_spec)
except:
pass
client.offset_table_add_with_os(sess_hdl, dev_tgt, match_spec,
priority, action_spec)
print "Port add done."
pr = 255
match_spec = flowSF_take_t_match_spec_t(2)
client.take_t_table_add_with_write2(sess_hdl, dev_tgt, match_spec)
match_spec = flowSF_take_t_match_spec_t(1)
client.take_t_table_add_with_write1(sess_hdl, dev_tgt, match_spec)
for kv in r:
match_spec = flowSF_getgoodsign_match_spec_t(kv[0], kv[1])
action_spec = flowSF_ggs_action_spec_t(kv[2])
client.getgoodsign_table_add_with_ggs(sess_hdl, dev_tgt, match_spec,
action_spec)
match_spec1 = flowSF_rdmz_match_spec_t(0)
match_spec2 = flowSF_rdmz_match_spec_t(1)
match_spec3 = flowSF_rdmz_match_spec_t(2)
match_spec4 = flowSF_rdmz_match_spec_t(3)
client.rdmz_table_add_with_rm1(sess_hdl, dev_tgt, match_spec2)
client.rdmz_table_add_with_rm1(sess_hdl, dev_tgt, match_spec4)
client.rdmz_table_add_with_rm2(sess_hdl, dev_tgt, match_spec1)
client.rdmz_table_add_with_rm2(sess_hdl, dev_tgt, match_spec3)
match_spec1 = flowSF_restore_match_spec_t(0)
match_spec2 = flowSF_restore_match_spec_t(1)
match_spec3 = flowSF_restore_match_spec_t(2)
match_spec4 = flowSF_restore_match_spec_t(3)
client.restore_table_add_with_rs1(sess_hdl, dev_tgt, match_spec2)
client.restore_table_add_with_rs1(sess_hdl, dev_tgt, match_spec4)
client.restore_table_add_with_rs2(sess_hdl, dev_tgt, match_spec1)
client.restore_table_add_with_rs2(sess_hdl, dev_tgt, match_spec3)
sign = 1
match_spec = flowSF_sign_t_match_spec_t(0)
action_spec = flowSF_signing_action_spec_t(sign)
try:
client.sign_t_table_delete_by_match_spec(sess_hdl, dev_tgt, match_spec)
except:
pass
client.sign_t_table_add_with_signing(sess_hdl, dev_tgt, match_spec,
action_spec)
'''considersleep'''
time1 = datetime.datetime.now()
x = 0
y = 0
z = 0
while True:
time2 = datetime.datetime.now()
if (time2 - time1).total_seconds() >= switchtime and x == 0:
print((time2 - time1).total_seconds())
sign1 = (sign + 2) % 4
x = 1
match_spec = flowSF_sign_t_match_spec_t(0)
action_spec = flowSF_signing_action_spec_t(sign1)
try:
client.sign_t_table_delete_by_match_spec(
sess_hdl, dev_tgt, match_spec)
except:
pass
client.sign_t_table_add_with_signing(sess_hdl, dev_tgt, match_spec,
action_spec)
time.sleep(0.1)
client.register_reset_all_rm_a(sess_hdl, dev_tgt)
if sign1 == 3:
client.register_reset_all_fs_a_1_1(sess_hdl, dev_tgt)
client.register_reset_all_fs_a_1_2(sess_hdl, dev_tgt)
client.register_reset_all_fs_b_1_1(sess_hdl, dev_tgt)
client.register_reset_all_fs_b_1_2(sess_hdl, dev_tgt)
print("clean sketch1")
if sign1 == 0:
client.register_reset_all_fs_a_2_1(sess_hdl, dev_tgt)
client.register_reset_all_fs_a_2_2(sess_hdl, dev_tgt)
client.register_reset_all_fs_b_2_1(sess_hdl, dev_tgt)
client.register_reset_all_fs_b_2_2(sess_hdl, dev_tgt)
print("clean sketch2")
time6 = datetime.datetime.now()
print((time6 - time2).total_seconds())
if (time2 - time1).total_seconds() >= totaltime:
print((time2 - time1).total_seconds())
z = 1
time1 = time2
sign = 3 - sign
x = 0
y = 0
match_spec = flowSF_sign_t_match_spec_t(0)
action_spec = flowSF_signing_action_spec_t(sign)
try:
client.sign_t_table_delete_by_match_spec(
sess_hdl, dev_tgt, match_spec)
except:
pass
client.sign_t_table_add_with_signing(sess_hdl, dev_tgt, match_spec,
action_spec)
from mudserve.combat.handler import CombatHandler from mudserve.mudrpc.combat import CombatService from thrift.transport import TSocket from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from thrift.server import TServer PORT = 9090 handler = CombatHandler() processor = CombatService.Processor(handler) transport = TSocket.TServerSocket(PORT) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TForkingServer(processor, transport, tfactory, pfactory) print "Starting the server on port %i..." % (PORT) server.serve() print "done."
self.position.z,
self.position.alfa)
sleep(0.5)
return True
def getCurrentDevice(self):
return "android"
def setDevice(self, device):
print "Selecting device name {}".format(device)
sleep(10)
return True
def reloaddutconfig(self, idx):
print "Reload config for dut {}".format(idx)
return
if __name__ == "__main__":
handler = RataServiceHandler()
processor = rataservice.Processor(handler)
transport = TSocket.TServerSocket(port=9090)
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
print "Server started"
try:
server.serve()
except KeyboardInterrupt:
os.kill(os.getpid(), signal.SIGKILL)
elif tag == 'cat':
puntero.execute("SELECT name FROM gifs WHERE tag = 'cat' ORDER BY popularidad DESC LIMIT 10")
elif tag == 'sports':
puntero.execute("SELECT name FROM gifs WHERE tag = 'sports' ORDER BY popularidad DESC LIMIT 10")
lista_gifs = []
for x in puntero:
res = (requests.get(x[0])).content
self.r.sadd(tag, res)
lista_gifs.append(res)
self.r.expire(tag, 60)
return lista_gifs
if __name__ == '__main__':
try:
handler = GifsvHandler()
processor = Gifsv.Processor(handler)
transport = TSocket.TServerSocket(host='127.0.0.1', port=9999)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
print('Its dangerous go alone')
print('Take this server')
server.serve()
logging.basicConfig(level=logging.DEBUG)
except:
print("error")
def __init__(self, class_, host, port):
self.transport = TSocket.TSocket(host, port)
protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
self.client = class_.Client(protocol)
self.transport.open()
# -*- coding:utf-8 -*-
import sys
sys.path.append('/usr/local/hadoop/hive/lib/py')
from thrift.transport import TSocket
from thrift.protocol import TBinaryProtocol
from thrift.transport import TTransport
from hbase import THBaseService
transport = TTransport.TBufferedTransport(TSocket.TSocket('127.0.0.1', 9090))
protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport)
client = THBaseService.Client(protocol)
transport.open()
# 使用 client 实例进行操作
# transport.close()
exception.code = 404
exception.mesage = 'Task not found'
raise exception
task = TaskHandler.convertInstance(instance)
return task
@staticmethod
def convertInstance(instance):
task = 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
if __name__ == '__main__':
port = 6000
handler = TaskHandler()
processor = Tasks.Processor(handler)
transport = TSocket.TServerSocket(port=port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print('main')
server.serve()
# Talk to a server via TCP sockets, using a binary protocol
from thrift.transport.TSocket import *
from thrift.protocol.TBinaryProtocol import *
from pylib.echo import *
transport = TSocket("localhost", 9090)
transport.open()
protocol = TBinaryProtocol(transport)
# Use the service we already defined
service = EchoService.Client(protocol)
returnValue = service.echo("Hello World!")
print returnValue
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):
print("sendMobileMessage")
return True
def sendEmailMessage(self):
print("sendEmailMessage")
return True
if __name__ == "__main__":
handler = MessageServiceHandler()
processor = MessageService.Processor(handler)
transport = TSocket.TServerSocket(host="0.0.0.0", port=8800)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("python thrift server start")
server.serve()
print("python thrift server exit")
