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
