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 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 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