def make_request(self, method, params, packet_type=ChannelPack.TYPE_RPC, response_type=ChannelPack.TYPE_RPC): rpc_data = self.encode_rpc_request(method, params) self.logger.debug("request rpc_data : {}".format(rpc_data)) seq = ChannelPack.make_seq32() request_pack = ChannelPack(packet_type, seq, 0, rpc_data) self.send_pack(request_pack) onresponse_emitter_str = ChannelHandler.getEmitterStr(self.onResponsePrefix, seq, response_type) # register onResponse emitter self.lock.acquire() self.callbackEmitter.on(onresponse_emitter_str, self.onResponse) self.lock.release() self.requests.append(onresponse_emitter_str) emitter_str = ChannelHandler.getEmitterStr(self.getResultPrefix, seq, response_type) def resolve_promise(resolve, reject): """ resolve promise """ # register getResult emitter self.lock.acquire() self.callbackEmitter.on(emitter_str, (lambda result, is_error: resolve( result) if is_error is False else reject(result))) self.lock.release() p = Promise(resolve_promise) return p.get()
def check_heatbeat(self): if time.time() - self.lastheatbeattime < self.heatbeatStamp: return pack = ChannelPack(ChannelPack.TYPE_HEATBEAT, ChannelPack.make_seq32(), 0, bytes("", "utf-8")) self.sendpack(pack) self.lastheatbeattime = time.time()
def send_hello(self, ): # 与服务端建立socket连接 with socket.create_connection((host, port)) as sock: #sock.send(bytes(testreq,"utf-8") ) # print("sent",testreq) #reply = sock.recv(4096) # print(reply) # 将socket打包成SSL socket print("connect {}:{},as socket {}".format(host, port, sock)) with context.wrap_socket(sock) as ssock: print(ssock) # 向服务端发送信息 buffer = ChannelPack.pack_all(ChannelPack.TYPE_RPC, testreq) ssock.send(buffer) # 接收服务端返回的信息 responsePack = None respbuffer = bytearray() for i in [0, 3]: msg = ssock.recv(1024 * 10) respbuffer += msg (code, len, responsePack) = ChannelPack.unpack(bytes(respbuffer)) i += 1 if code != 0: continue if len > 0: respbuffer = respbuffer[len:] if code == 0: break print(responsePack.result, responsePack.data) ssock.close()
def register_event_callback(addresses, event_name, indexed_value): topics = [] topic0 = parser.topic_from_event_name(event_name) topics.append(topic0) event_abi = parser.event_name_map[event_name] print("event abi:", event_abi) if len(indexed_value) > 0: indexedinput = [] for input in event_abi["inputs"]: if input["indexed"] is True: indexedinput.append((input['name'], input['type'])) print(indexedinput) i = 0 for v in indexed_value: itype = indexedinput[i][1] topic = DatatypeParser.topic_from_type(itype, v) if not (topic is None): topics.append(topic) i = i + 1 requestJson = format_event_register_request("latest", "latest", addresses, topics) requestbytes = ChannelPack.pack_amop_topic_message("", requestJson) client.channel_handler.pushDispacher.add_handler( ChannelPack.EVENT_LOG_PUSH, eventHandler01) client.channel_handler.pushDispacher.add_handler( ChannelPack.EVENT_LOG_PUSH, eventHandler02) response = client.channel_handler.make_channel_request( requestbytes, ChannelPack.CLIENT_REGISTER_EVENT_LOG, ChannelPack.CLIENT_REGISTER_EVENT_LOG) (topic, result) = ChannelPack.unpack_amop_topic_message(response) dataobj = json.loads(result) print("after register ,event_name:{},topic:{},result:{}".format( event_name, topic, dataobj['result']))
def make_channel_request(self, data, packet_type, response_type=None): seq = ChannelPack.make_seq32() request_pack = ChannelPack(packet_type, seq, 0, data) self.send_pack(request_pack) onresponse_emitter_str = ChannelHandler.getEmitterStr( self.onResponsePrefix, seq, response_type) # register onResponse emitter self.lock.acquire() self.callbackEmitter.on(onresponse_emitter_str, self.onResponse) self.lock.release() self.requests.append(onresponse_emitter_str) # register onResponse emitter of RPC rpc_onresponse_emitter_str = None rpc_result_emitter_str = None if response_type is ChannelPack.TYPE_TX_COMMITTED \ or response_type is ChannelPack.CLIENT_REGISTER_EVENT_LOG: rpc_onresponse_emitter_str = ChannelHandler.getEmitterStr( self.onResponsePrefix, seq, packet_type) self.requests.append(rpc_onresponse_emitter_str) rpc_result_emitter_str = ChannelHandler.getEmitterStr( self.getResultPrefix, seq, packet_type) self.lock.acquire() self.callbackEmitter.on(rpc_onresponse_emitter_str, self.onResponse) self.lock.release() emitter_str = ChannelHandler.getEmitterStr(self.getResultPrefix, seq, response_type) def resolve_promise(resolve, reject): """ resolve promise """ # register getResult emitter self.lock.acquire() self.callbackEmitter.on(emitter_str, (lambda result, is_error: resolve(result))) # 1. if send transaction failed, return the error message directly # and erase the registered 0x1002 emitter # 2. if send transaction success, remove the registered 0x12 emitter if rpc_result_emitter_str is not None: self.callbackEmitter.on( rpc_result_emitter_str, (lambda result, is_error: resolve(result) and self.requests .remove(onresponse_emitter_str) if is_error is True else self.requests.remove(rpc_onresponse_emitter_str) if self. requests.count(rpc_onresponse_emitter_str) else None)) self.lock.release() p = Promise(resolve_promise) # default timeout is 60s return p.get(60)
def getBlockNumber(self, groupId): """ get block number notify """ block_notify_emitter = ChannelHandler.getEmitterStr(self.onResponsePrefix, ChannelPack.get_seq_zero(), ChannelPack.TYPE_TX_BLOCKNUM) self.callbackEmitter.on(block_notify_emitter, self.onResponse) self.logger.debug("block notify emitter: {}".format(block_notify_emitter)) self.requests.append(block_notify_emitter) seq = ChannelPack.make_seq32() topic = json.dumps(["_block_notify_{}".format(groupId)]) request_pack = ChannelPack(ChannelPack.TYPE_TOPIC_REPORT, seq, 0, topic) self.send_pack(request_pack)
def make_request(self, method, params, type=ChannelPack.TYPE_RPC): stat = StatTool.begin() rpc_data = self.encode_rpc_request(method,params) self.logger.debug("request rpc_data : {}".format(rpc_data) ) #print("request rpc_data", rpc_data) request_pack = ChannelPack(type,ChannelPack.make_seq32(), 0,rpc_data) res = self.send_pack(request_pack) starttime = time.time() responsematch = False while time.time() - starttime < 10: # spend max 10 sec to wait a correct response try: theQueue = self.recvThread.getQueue(ChannelPack.TYPE_RPC) responsepack = theQueue.get(block=True, timeout=3) # pop msg from queue except Empty as e: continue #print("got a pack from queue, detail:{}".format(responsepack.detail())) self.logger.debug("got a pack from queue, detail:{}".format(responsepack.detail())) if responsepack.type == ChannelPack.TYPE_RPC and responsepack.seq == request_pack.seq: responsematch = True break else: #print("*******SKIP!!!! pack ", responsepack.detail()) self.logger.debug("*******SKIP!!!! pack {}".format( responsepack.detail() )) responsepack = None continue if responsematch == False: raise BcosError(102,None,"timeout") result = responsepack.result data = responsepack.data.decode("utf-8") msg = "success" if(result!=0): if result in self.errorMsg: msg = "unknow error %d"%result msg = self.errorMsg[result] raise BcosError(result,msg) response = FriendlyJsonSerde().json_decode(data) stat.done() stat.debug("make_request:{}".format(method) ) self.logger.debug("GetResponse. %s, Response: %s", method, response) #print("response from server:",response) self.logger.debug("response from server: {}".format( response) ) if "result" not in response: tempresp =dict() tempresp["result"] = response response =tempresp return response
def read_channel(self): # 接收服务端返回的信息 try: self.logger.debug("{} channelHandler.ssock.recv begin.".format( self.name)) msg = self.channelHandler.ssock.recv(1024 * 1024 * 10) self.logger.debug("channelHandler.ssock.recv len:{}".format( len(msg))) if msg is None: return -1 if len(msg) == 0: return 0 except Exception as e: self.logger.error("{}:ssock read error {}".format(self.name, e)) return -1 self.respbuffer += msg # if no enough data even for header ,continue to read if len(self.respbuffer) < ChannelPack.getheaderlen(): return len(msg) code = 0 # decode all packs in buffer from node,maybe got N packs on one read # -1 means no enough bytes for decode, should break to continue read and wait while code != -1: (code, decodelen, responsePack) = ChannelPack.unpack(bytes(self.respbuffer)) # print("respbuffer:",self.respbuffer) if decodelen > 0: # cut the buffer from last decode pos self.respbuffer = self.respbuffer[decodelen:] if code != -1 and responsePack is not None: # got a pack # print("get a pack from node, put to queue {}".format(responsePack.detail())) self.logger.debug( "{}:pack from node, put queue(qsize{}),detail {}".format( self.name, self.recvQueue.qsize(), responsePack.detail())) if self.recvQueue.full(): self.recvQueue.get( ) # if queue full ,pop the head item ,!! the item LOST self.logger.error( "{}:queue {} FULL pop and LOST: {}".format( self.name, responsePack.type, responsePack.detail())) self.recvQueue.put(responsePack) # self.print_queue() return len(msg)
def on_push(self, packmsg: ChannelPack): print("EventPushHandler", packmsg.detail()) strmsg = packmsg.data.decode("utf-8") response = json.loads(strmsg) print("response filterID:", response['filterID']) #print("response:", json.dumps(response,indent=4)) loglist = parser.parse_event_logs(response["logs"]) print(json.dumps(loglist, indent=4))
def on_push(self, packmsg: ChannelPack): print(">>>>>>>>>>>>>>>>>>EventPushHandler02", packmsg.detail()) strmsg = packmsg.data.decode("utf-8") response = json.loads(strmsg) loglist = parser.parse_event_logs(response["logs"]) print("FilterID ", response["filterID"]) print(">>>>>>>>>>>>>>>>>>EventPushHandler02", json.dumps(loglist, indent=4))
def register_eventlog_filter( self, eventcallback, abiparser, addresses, event_name, indexed_value=None, fromblock="latest", to_block="latest"): topics = [] if event_name is not None: topic0 = abiparser.topic_from_event_name(event_name) topics.append(topic0) event_abi = abiparser.event_name_map[event_name] #print("event abi:", event_abi) if indexed_value is not None and len(indexed_value) > 0: indexedinput = [] for event_input in event_abi["inputs"]: if event_input["indexed"] is True: indexedinput.append((event_input['name'], event_input['type'])) # print(indexedinput) i = 0 for v in indexed_value: itype = indexedinput[i][1] topic = DatatypeParser.topic_from_type(itype, v) if not (topic is None): topics.append(topic) i = i + 1 # create new filterid by uuid seq = uuid.uuid1() filterid = seq.hex requestJson = self.format_event_register_request( fromblock, to_block, addresses, topics, self.client.groupid, filterid) requestbytes = ChannelPack.pack_amop_topic_message("", requestJson) response = self.client.channel_handler.make_channel_request( requestbytes, ChannelPack.CLIENT_REGISTER_EVENT_LOG, ChannelPack.CLIENT_REGISTER_EVENT_LOG) (topic, result) = ChannelPack.unpack_amop_topic_message(response) dataobj = json.loads(result) # print(dataobj) if dataobj["result"] == 0: self.ecb_manager.set_callback(filterid, eventcallback) return dataobj
from client.channelpack import ChannelPack from eth_utils import encode_hex import json seq = b"123456789012345678900123456789012" data = "{\"jsonrpc\":\"2.0\",\"method\":\"getClientVersion\",\"params\":[],\"id\":1}" json.loads(data) print("datalen ", len(data)) pack = ChannelPack(0x12, seq, 0, data) packres = pack.pack() print(encode_hex(packres)) aa = [] b = dict() aa.append({"test", 1}) aa.append({"test", 2}) print(b) print(json.dumps(b))