def make_stop_training_req(in_task_id): m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = STOP_TRAINING_REQ nonce = get_random_id() session_id = get_random_id() head = msg_header(get_magic(), msg_name, nonce, session_id) print("stop req.nonce:%s, task_id:%s" % (nonce, in_task_id)) req = stop_training_req_body(in_task_id) message = in_task_id + nonce sign_algo = "ecdsa" origin = get_node_id() exten_info = {} exten_info["origin_id"] = origin exten_info["sign_algo"] = sign_algo exten_info["sign"] = dbc_sign(message) head.exten_info = exten_info head.write(p) req.write(p) p.writeMessageEnd() m.flush() return pack_head(m)
def make_broad_cast_node_info(node_id, name): m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = SERVICE_BROADCAST_REQ nonce = get_random_id() head = msg_header(get_magic(), msg_name, nonce) head.write(p) node_info = node_service_info() node_info.name = name node_info.time_stamp = int(time.time()) service_list = [] service_list.append("ai_training") node_info.service_list = service_list kvs = {} kvs["gpu"] = "1 * GeForce940MX" kvs["state"] = "idle" node_info.kvs = kvs node_map = {} node_map[node_id] = node_info req = service_broadcast_req_body(node_map) req.write(p) p.writeMessageEnd() m.flush() return pack_head(m)
def make_get_peer_nodes_resp(dport): m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = P2P_GET_PEER_NODES_RESP nonce = get_random_id() head = msg_header(get_magic(), msg_name, nonce) head.write(p) print("nonce:%s" % (nonce)) # self.peer_node_id = peer_node_id # self.core_version = core_version # self.protocol_version = protocol_version # self.live_time_stamp = live_time_stamp # self.addr = addr node_list = [] node_info = peer_node_info() node_info.addr = network_address("10.10.254.198", dport) node_info.peer_node_id = gen_node_id() node_info.core_version = core_version node_info.protocol_version = pro_version node_info.live_time_stamp = int(time.time()) node_list.append(node_info) req = get_peer_nodes_resp_body(node_list) req.write(p) p.writeMessageEnd() m.flush() return pack_head(m)
def createRpcClient(self): # Set up thrift client and contact server if config["use_pswitch"] == 0: if self.test_params.has_key("server"): server = self.test_params['server'] else: server = 'localhost' self.transport = TSocket.TSocket(server, 9092) self.transport = TTransport.TBufferedTransport(self.transport) self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport) self.client = switch_sai_rpc.Client(self.protocol) self.transport.open() return if config["use_pswitch"] == 1: if self.test_params.has_key("server"): server = self.test_params['server'] else: server = 'localhost' self.transport = TSocket.TSocket(server, config["thrift_port"]) self.transport = TTransport.TFramedTransport(self.transport) #self.protocol = TJSONProtocol(self.transport) self.protocol = TBinaryProtocol(self.transport) self.client = switch_sai_rpc.Client(self.protocol) self.transport.open() return
def writeString(self, v): """ 只要控制好了writeString, 在整个thrift系统中,所有的字符串都是utf-8格式的 """ if isinstance(v, unicode): v = v.encode("utf-8") # TBinaryProtocol 为 old style class TBinaryProtocol.writeString(self, v)
def writeMessageBegin(self, name, type, seqid): self.start = time.time() if (type == TMessageType.CALL or type == TMessageType.ONEWAY) and self.service_name_: self.last_name = self.service_name_ + name TBinaryProtocol.writeMessageBegin(self, self.last_name, type, seqid) else: self.last_name = name TBinaryProtocol.writeMessageBegin(self, name, type, seqid)
def __init__(self, trans, service_name=None, fastbinary=False, logger=None): TBinaryProtocol.__init__(self, trans, False, True) if service_name: self.service_name_ = service_name + SEPARATOR else: self.service_name_ = None self.logger = logger self.last_name = None self.start = None
def get_request_object(self, msg): """TODO""" trans = TTransport.TMemoryBuffer(msg) proto = TBinaryProtocol(trans) (name, type, seqid) = proto.readMessageBegin() # assert type == TODO r = self._args_struct() r.read(proto) return getattr(r, "request", ())
def write_to_read(write_struct, read_struct): write_buffer = TMemoryBuffer() write_protocol = TBinaryProtocol(write_buffer) write_struct.write(write_protocol) # The implementation of TMemoryBuffer is slightly different from C++ # the read/write buffer is not shared, thus we have to create another # TMemoryBuffer read_buffer = TMemoryBuffer(write_buffer.getvalue()) read_protocol = TBinaryProtocol(read_buffer) read_struct.read(read_protocol)
def make_ver_resp(): m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = VER_RESP nonce = get_random_id() head = msg_header(get_magic(), msg_name, nonce) head.write(p) req = ver_resp_body(gen_node_id(), core_version, pro_version) req.write(p) p.writeMessageEnd() m.flush() return pack_head(m)
def post(self): """Thrift HTTP POST request. Translates the POST body to the thrift request, and returns the serialized thrift message in the response body. Sets the approprate HTTP Content-Type header as well. """ iprot = TBinaryProtocol(TMemoryBuffer(self.request.body)) oprot = TBinaryProtocol(TMemoryBuffer()) self.processor.process(iprot, oprot) self.set_header('Content-Type', 'application/x-thrift') self.write(oprot.trans.getvalue())
def thrift_objs_in_bytes(thrift_obj_list): # pragma: no cover """ Returns TBinaryProtocol encoded Thrift objects. :param thrift_obj_list: thrift objects list to encode :returns: thrift objects in TBinaryProtocol format bytes. """ transport = TMemoryBuffer() protocol = TBinaryProtocol(transport) protocol.writeListBegin(TType.STRUCT, len(thrift_obj_list)) for thrift_obj in thrift_obj_list: thrift_obj.write(protocol) return bytes(transport.getvalue())
def make_start_training_req(code_hash, entry_file,engine,peer_nodes,hyper_params,data_hash=""): try: m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = AI_TRAINING_NOTIFICATION_REQ nonce = get_random_id() head = msg_header(get_magic(), msg_name, nonce) # head.write(p) task_id = get_random_id() print ("task_id: %s, nonce:%s"%(task_id,nonce)) # select_mode=bytes(result["select_mode"])[0] select_mode = 0x00 master = "" pns = peer_nodes peer_nodes_list = pns.split(",") server_specification ="" server_count = 0 #training_engine = result["training_engine"] training_engine = engine code_dir = code_hash entry_file = entry_file data_dir = data_hash checkpoint_dir = "" hyper_parameters = hyper_params req = start_training_req_body(task_id, select_mode, master, peer_nodes_list, server_specification, server_count, training_engine, code_dir, entry_file, data_dir, checkpoint_dir, hyper_parameters) message=task_id+code_dir+nonce print("message:",message) sign_algo="ecdsa" origin=get_node_id() # print("sign_origin:", origin) exten_info={} exten_info["origin_id"]=origin exten_info["sign_algo"]=sign_algo exten_info["sign"] = dbc_sign(message) print("sign:", exten_info["sign"]) head.exten_info = exten_info head.write(p) req.write(p) p.writeMessageEnd() m.flush() return task_id, pack_head(m) except EOFError: print("Error: msg body decode failure") return except IOError: print ("Error: IO Error") return
def make_list_training_req(in_task_id): m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = STOP_TRAINING_REQ nonce = get_random_id() session_id = get_random_id() head = msg_header(get_magic(), msg_name, nonce, session_id) print("list req.nonce:%s, task_id:%s" % (nonce, in_task_id)) req = list_training_req_body(in_task_id) head.write(p) req.write(p) p.writeMessageEnd() m.flush() return pack_head(m)
def wraps(*args, **kwargs): user_store_http_client = THttpClient(settings.EVERNOTE_STORE_URI) user_store_protocol = TBinaryProtocol(user_store_http_client) user_store = UserStore.Client(user_store_protocol) note_store_url = user_store.getNoteStoreUrl( settings.EVERNOTE_DEVELOPER_TOKEN) note_store_http_client = THttpClient(note_store_url) note_store_protocol = TBinaryProtocol(note_store_http_client) note_store = NoteStore.Client(note_store_protocol) kwargs['user_store'] = user_store kwargs['note_store'] = note_store return func(*args, **kwargs)
def http_handler(request): if request.method != 'POST': return HttpResponseNotAllowed(['GET', 'PUT']) server_info.client_ip = request.META['REMOTE_ADDR'] if server_info.client_ip[0:7] == '::ffff:': server_info.client_ip = server_info.client_ip[7:] server_info.client_port = None itrans = TMemoryBuffer(request.body) otrans = TMemoryBuffer() iproto = TBinaryProtocol(itrans) oproto = TBinaryProtocol(otrans) thrift_handler(iproto, oproto) return HttpResponse(otrans.getvalue(), content_type="application/x-thrift")
def __init__(self, host=None, port=10000, authMechanism=None, user=None, password=None, database=None, configuration=None): super(Connection, self).__init__(authMechanism) #Must set a password for thrift, even if it doesn't need one #Open issue with python-sasl password = self._check_password(authMechanism, password) socket = TSocket(host, port) if authMechanism == 'NOSASL': transport = TBufferedTransport(socket) else: saslc, sasl_mech = self._get_sasl_client(host, authMechanism, user, password, configuration) transport = TSaslClientTransport(saslc, sasl_mech, socket) self.client = TCLIService.Client(TBinaryProtocol(transport)) transport.open() res = self.client.OpenSession( TOpenSessionReq(configuration=configuration)) self.session = res.sessionHandle if database is not None: with self.cursor() as cur: query = "USE {0}".format(database) cur.execute(query)
def decode_binary(self, bs): m = TMemoryBuffer(bs) p = TBinaryProtocol(m) try: # h = msg_header() h = ttypes_header.msg_header() h.read(p) except EOFError: print "Error: msg header decode failure" return if not h.msg_name: print "Error: msg header decode failure" return self.header = h s = h.msg_name + "_body" if s in globals(): t = globals()[s] else: t = empty try: body = t() body.read(p) except EOFError: print "Error: msg body decode failure" return self.body = body
def connect_to_thrift(conf): """ Connect to a thrift endpoint as determined by the 'conf' parameter. Note that this does *not* open the transport. Returns a tuple of (service, protocol, transport) """ sock = TSocket(conf.host, conf.port) if conf.timeout_seconds: # Thrift trivia: You can do this after the fact with # _grab_transport_from_wrapper(self.wrapped.transport).setTimeout(seconds*1000) sock.setTimeout(conf.timeout_seconds * 1000.0) if conf.use_sasl: def sasl_factory(): saslc = sasl.Client() saslc.setAttr("host", conf.host) saslc.setAttr("service", conf.kerberos_principal) saslc.init() return saslc transport = TSaslClientTransport(sasl_factory, "GSSAPI", sock) else: transport = TBufferedTransport(sock) protocol = TBinaryProtocol(transport) service = conf.klass(protocol) return service, protocol, transport
def main(argv): p = argparse.ArgumentParser() add_common_args(p) # Since THeaderTransport acts as framed transport when detected frame, we # cannot use --transport=framed as it would result in 2 layered frames. p.add_argument('--override-transport') p.add_argument('--override-protocol') args = p.parse_args() assert args.protocol == 'header' assert args.transport == 'buffered' assert not args.ssl sock = TSocket(args.host, args.port, socket_family=socket.AF_INET) if not args.override_transport or args.override_transport == 'buffered': trans = TBufferedTransport(sock) elif args.override_transport == 'framed': print('TFRAMED') trans = TFramedTransport(sock) else: raise ValueError('invalid transport') trans.open() if not args.override_protocol or args.override_protocol == 'binary': proto = TBinaryProtocol(trans) elif args.override_protocol == 'compact': proto = TCompactProtocol(trans) else: raise ValueError('invalid transport') test_void(proto) test_void(proto) trans.close()
def __init__(self, host=None, port=10000, authMechanism=None, user=None, password=None, database=None, cursorclass=Cursor): authMechanisms = set(['NOSASL', 'PLAIN', 'KERBEROS', 'LDAP']) if authMechanism not in authMechanisms or authMechanism == 'KERBEROS': raise NotImplementedError( 'authMechanism is either not supported or not implemented') #Must set a password for thrift, even if it doesn't need one #Open issue with python-sasl if authMechanism == 'PLAIN' and (password is None or len(password) == 0): password = '******' socket = TSocket(host, port) self.cursorclass = cursorclass if authMechanism == 'NOSASL': transport = TBufferedTransport(socket) else: saslc = sasl.Client() saslc.setAttr("username", user) saslc.setAttr("password", password) saslc.init() transport = TSaslClientTransport(saslc, "PLAIN", socket) self.client = TCLIService.Client(TBinaryProtocol(transport)) transport.open() res = self.client.OpenSession(TOpenSessionReq()) self.session = res.sessionHandle if database is not None: with self.cursor() as cur: query = "USE {0}".format(database) cur.execute(query)
def create( cls, host, port=DEFAULT_AURORA_PORT, encoding='json'): """ Parses a host name and sets up Torando and Thrift client """ # To recieve and send binary thrift to the Aurora master we need to set # headers appropriately. transport = THttpClient('http://%s:%s/api' % (host, str(port))) # Set aurora credentials in transport header if the environment # variables have been set if os.getenv('AURORA_USERNAME') and os.getenv('AURORA_PASSWORD'): username = os.getenv('AURORA_USERNAME') password = os.getenv('AURORA_PASSWORD') credentials = base64.encodestring( '%s:%s' % (username, password)).replace('\n', '') auth_header = "Basic %s" % credentials transport.setCustomHeaders({'Authorization': auth_header}) if encoding == 'binary': transport.setCustomHeaders({ 'Content-Type': 'application/vnd.apache.thrift.binary', 'Accept': 'application/vnd.apache.thrift.binary', }) protocol = TBinaryProtocol(transport) elif encoding == 'json': protocol = TJSONProtocol(transport) else: raise Exception('Unknown encoding %s' % encoding) client = Client(protocol) return client
def __init__(self, host, port): self.host = host self.port = port self.socket = TSocket.TSocket(host, port) self.transport = TTransport.TFramedTransport(self.socket) self.protocol = TBinaryProtocol(self.transport) self.client = Thrift4DLService.Client(self.protocol)
def create(cls, host, port=DEFAULT_AURORA_PORT, encoding="json"): """ Parses a host name and sets up Torando and Thrift client """ # To recieve and send binary thrift to the Aurora master we need to set # headers appropriately. transport = THttpClient("http://%s:%s/api" % (host, str(port))) # Set aurora credentials in transport header if the environment # variables have been set if os.getenv("AURORA_USERNAME") and os.getenv("AURORA_PASSWORD"): username = os.getenv("AURORA_USERNAME") password = os.getenv("AURORA_PASSWORD") credentials = base64.encodestring( "%s:%s" % (username, password) ).replace("\n", "") auth_header = "Basic %s" % credentials transport.setCustomHeaders({"Authorization": auth_header}) if encoding == "binary": transport.setCustomHeaders( { "Content-Type": "application/vnd.apache.thrift.binary", "Accept": "application/vnd.apache.thrift.binary", } ) protocol = TBinaryProtocol(transport) elif encoding == "json": protocol = TJSONProtocol(transport) else: raise Exception("Unknown encoding %s" % encoding) client = Client(protocol) return client
def create_transaction_with_smart_contract(self, code, fee, keys): tr = Transaction() contract = SmartContractInvocation() contract.smartContractDeploy = SmartContractDeploy() if code == "": code = 'import com.credits.scapi.annotations.*; import com.credits.scapi.v0.*; public class ' \ 'MySmartContract extends SmartContract { public MySmartContract() {} public String hello2(String ' \ 'say) { return \"Hello\" + say; } }' contractText = self.normalizeCode(code) result = self.compile_smart(contractText) contract.smartContractDeploy.byteCodeObjects = result.byteCodeObjects tr.smartContract = contract tr.smartContract.smartContractDeploy.sourceCode = contractText tr.source = keys.public_key_bytes w = self.client.WalletTransactionsCountGet(tr.source) lastInnerId = bytearray( (w.lastTransactionInnerId + 1).to_bytes(6, 'little')) tr.id = int.from_bytes(lastInnerId, byteorder='little', signed=False) tr.target = self.createContractAddress(tr.source, lastInnerId, contract) tr.amount = Amount() tr.amount.integral = 0 tr.amount.fraction = 0 tr.balance = Amount() tr.balance.integral = 0 tr.balance.fraction = 0 tr.currency = 1 tr.fee = AmountCommission() tr.fee.commission = self.double_to_fee(fee) tr.userFields = "" ufNum1 = bytearray(b'\x01') contract.smartContractDeploy.hashState = "" contract.smartContractDeploy.tokenStandard = 0 contract.method = "" contract.params = [] contract.usedContracts = [] contract.forgetNewState = False transportOut = TMemoryBuffer() protocolOut = TBinaryProtocol(transportOut) contract.write(protocolOut) scBytes = transportOut.getvalue() sMap = '=6s32s32slqhb1s4s' + str( len(scBytes) ) + 's' #4s' + str(scriptLength) + 's4s' + str(codeNameLength) + 's4s' + str(codeLength) + 's' #len(userField_bytes) serial_transaction_for_sign = pack( sMap, #'=' - without alignment lastInnerId, #6s - 6 byte InnerID (char[] C Type) tr.source, #32s - 32 byte source public key (char[] C Type) tr.target, #32s - 32 byte target pyblic key (char[] C Type) tr.amount.integral, #i - 4 byte integer(int C Type) tr.amount.fraction, #q - 8 byte integer(long long C Type) tr.fee.commission, #h - 2 byte integer (short C Type) tr.currency, #b - 1 byte integer (signed char C Type) ufNum1, bytes(len(scBytes).to_bytes(4, byteorder="little")), scBytes) signing_key = ed25519.SigningKey( keys.private_key_bytes) # Create object for calulate signing tr.signature = signing_key.sign(serial_transaction_for_sign) return tr
def get_doc_hot_by_thread(docid_list): docid_hot_list = [] r = redis.Redis(host='***', port=1680, password='******', charset='gbk') redis_result_list = [] try: redis_result_list = r.mget(docid_list) if redis_result_list is not None and len(redis_result_list) == len( docid_list): for i in range(len(redis_result_list)): if redis_result_list[i] is None or len( redis_result_list[i]) == 0: continue docid = docid_list[i] tMemory_o = TMemoryBuffer(redis_result_list[i]) tBinaryProtocol_o = TBinaryProtocol(tMemory_o) hot_feature = HotFeature() hot_feature.read(tBinaryProtocol_o) pv = hot_feature.app_show_num if hot_feature.app_show_num is not None else 0 cl = hot_feature.app_read_num if hot_feature.app_read_num is not None else 0 readtime = hot_feature.app_read_duration_double if hot_feature.app_read_duration_double is not None else 0 coldstart_pv = hot_feature.coldstart_show_num if hot_feature.coldstart_show_num is not None else 0 coldstart_cl = hot_feature.coldstart_read_num if hot_feature.coldstart_read_num is not None else 0 docid_hot_list.append( (docid, pv, cl, readtime, coldstart_pv, coldstart_cl)) except: traceback.print_exc() return docid_hot_list
def from_bytes(klass, data): """Returns thrift object from a string, using standard binary representation.""" obj = klass() b = TMemoryBuffer(data) p = TBinaryProtocol(b) obj.read(p) return obj
def connect_to_thrift(conf): """ Connect to a thrift endpoint as determined by the 'conf' parameter. Note that this does *not* open the transport. Returns a tuple of (service, protocol, transport) """ if conf.transport_mode == 'http': mode = THttpClient(conf.http_url) mode.set_verify(conf.validate) else: if conf.use_ssl: try: from ssl import PROTOCOL_TLS PROTOCOL_SSLv23 = PROTOCOL_TLS except ImportError: try: from ssl import PROTOCOL_SSLv23 as PROTOCOL_TLS PROTOCOL_SSLv23 = PROTOCOL_TLS except ImportError: PROTOCOL_SSLv23 = PROTOCOL_TLS = 2 mode = TSSLSocketWithWildcardSAN(conf.host, conf.port, validate=conf.validate, ca_certs=conf.ca_certs, keyfile=conf.keyfile, certfile=conf.certfile, ssl_version=PROTOCOL_SSLv23) else: mode = TSocket(conf.host, conf.port) if conf.timeout_seconds: # Thrift trivia: You can do this after the fact with # _grab_transport_from_wrapper(self.wrapped.transport).setTimeout(seconds*1000) mode.setTimeout(conf.timeout_seconds * 1000.0) if conf.transport_mode == 'http': if conf.use_sasl and conf.mechanism != 'PLAIN': mode.set_kerberos_auth(service=conf.kerberos_principal) else: mode.set_basic_auth(conf.username, conf.password) if conf.transport_mode == 'socket' and conf.use_sasl: def sasl_factory(): saslc = sasl.Client() saslc.setAttr("host", str(conf.host)) saslc.setAttr("service", str(conf.kerberos_principal)) if conf.mechanism == 'PLAIN': saslc.setAttr("username", str(conf.username)) saslc.setAttr("password", str(conf.password)) # Defaults to 'hue' for a non-empty string unless using LDAP else: saslc.setAttr("maxbufsize", SASL_MAX_BUFFER.get()) saslc.init() return saslc transport = TSaslClientTransport(sasl_factory, conf.mechanism, mode) elif conf.transport == 'framed': transport = TFramedTransport(mode) else: transport = TBufferedTransport(mode) protocol = TBinaryProtocol(transport) if conf.multiple: protocol = TMultiplexedProtocol(protocol, conf.service_name) service = conf.klass(protocol) return service, protocol, transport
def __init__(self, host, port, timeout_ms=900000, socket=None, do_open=True, framed=True): # if ssl: # socket = TSSLSocket.TSSLSocket( # host, port, validate=validate, ca_certs=ca_certs, keyfile=keyfile, certfile=certfile) s = TSocket.TSocket(host, port) if socket: s.setHandle(s) s.setTimeout(timeout_ms) if framed: self.transport = TTransport.TFramedTransport(s) else: self.transport = TTransport.TBufferedTransport(s) Service.Client.__init__(self, TBinaryProtocol(self.transport)) if not socket and do_open: self.open()
def make_shake_hand(self): m = TMemoryBuffer() p = TBinaryProtocol(m) msg_name = SHAKE_HAND_REQ head = msg_header(get_magic(), msg_name) head.write(p) req = shake_hand_req() req.write(p) p.writeMessageEnd() m.flush() buff = pack_head(m) # send_s = binascii.hexlify(buff) # print(send_s) self.send(buff) interval = 5 timer = threading.Timer(interval, self.make_shake_hand) timer.start()
def readMessageBegin(self): self.trans.read(4) # 跳过4字节的FrameSize name, type, seqid = TBinaryProtocol.readMessageBegin(self) if self.logger: # 开始读到了,才打印 elapsed = (time.time() - self.start) * 1000 self.logger.info("\033[35m[RPC] %s\033[39m[%s] ends, Elapsed: %.3fms", self.last_name, seqid, elapsed) return name, type, seqid
def call(self, procedure, args): if isinstance(procedure, str): try: procedure = processor._procedures[procedure] except KeyError: raise TApplicationException(TApplicationException.UNKNOWN_METHOD, "Unknown method '{0}'".format(name)) otrans = TMemoryBuffer() oproto = TBinaryProtocol(otrans) # perf.begin('send') oproto.writeMessageBegin(procedure.name, TMessageType.CALL, self._processor.seqid) self._processor.seqid = self._processor.seqid + 1 self._processor.send_struct(Namespace(args), procedure.parameters_struct, oproto) oproto.writeMessageEnd() # perf.end('send') self._http.request('POST', self._url, otrans.getvalue(), {}) resp = self._http.getresponse() data = resp.read() iproto = TBinaryProtocol(TMemoryBuffer(data)) # perf.begin('wait') (fname, mtype, rseqid) = iproto.readMessageBegin() # perf.end('wait') # perf.begin('recv') if mtype == TMessageType.EXCEPTION: x = TApplicationException() x.read(iproto) iproto.readMessageEnd() x.args = (x.message,) raise x result = self._processor.recv_struct(procedure.results_struct, iproto) iproto.readMessageEnd() # perf.end('recv') # perf.end('call') if result.result is not None: return result.result for field in procedure.results_struct.fields: if getattr(result, field.name) is not None: raise getattr(result, field.name) return None
def writeMessageBegin(self, name, type, seqid): assert isinstance(self.trans, TZmqTransport) # 在数据输出之前,先设置好: service self.trans.service = self.service TBinaryProtocol.writeMessageBegin(self, name, type, seqid)
def __init__(self, trans, strictRead=False, strictWrite=True, service=None): TBinaryProtocol.__init__(self, trans, strictRead, strictWrite) self.service = service
def decode_message(data): trans = TMemoryBuffer(data) proto = TBinaryProtocol(trans) return proto.readString()
def __init__(self, trans): TBinaryProtocol.__init__(self, trans) self.strictRead = False self.strictWrite = True self.trace_context = getTraceContext()
def create_message(data): trans = TMemoryBuffer() proto = TBinaryProtocol(trans) proto.writeString(data) return trans.getvalue()
def main(argv): p = argparse.ArgumentParser() add_common_args(p) # Since THeaderTransport acts as framed transport when detected frame, we # cannot use --transport=framed as it would result in 2 layered frames. p.add_argument('--override-transport') args = p.parse_args() assert args.protocol == 'header' assert args.transport == 'buffered' assert not args.ssl sock = TSocket(args.host, args.port, socket_family=socket.AF_INET) if not args.override_transport or args.override_transport == 'buffered': trans = TBufferedTransport(sock) elif args.override_transport == 'framed': trans = TFramedTransport(sock) else: raise ValueError('invalid transport') trans.open() proto = TBinaryProtocol(trans) proto.writeMessageBegin('testVoid', TMessageType.CALL, 3) proto.writeStructBegin('testVoid_args') proto.writeFieldStop() proto.writeStructEnd() proto.writeMessageEnd() trans.flush() _, mtype, _ = proto.readMessageBegin() assert mtype == TMessageType.REPLY proto.readStructBegin() _, ftype, _ = proto.readFieldBegin() assert ftype == TType.STOP proto.readFieldEnd() proto.readStructEnd() proto.readMessageEnd() trans.close()
def writeString(self, str): if isinstance(str, unicode): str = str.encode("utf-8") TBinaryProtocol.writeString(self, str)