async def publish_new_block(ws, channel_name, height, peer_id): call_method = WSDispatcher.PUBLISH_NEW_BLOCK channel_stub = get_channel_stub_by_channel_name(channel_name) try: while True: new_block_dumped, confirm_info_bytes = await channel_stub.async_task().announce_new_block( subscriber_block_height=height, subscriber_id=peer_id ) new_block: dict = json.loads(new_block_dumped) if "error" in new_block: Logger.error(f"announce_new_block error: {new_block}, to citizen({peer_id})") break confirm_info = confirm_info_bytes.decode('utf-8') request = Request(call_method, block=new_block, confirm_info=confirm_info) Logger.debug(f"{call_method}: {request}") await ws.send(json.dumps(request)) height += 1 except exceptions.ConnectionClosed: Logger.debug("Connection Closed by child.") # TODO: Useful message needed. except Exception as e: traceback.print_exc() # TODO: Keep this tb? await WSDispatcher.send_exception( ws, call_method, exception=e, error_code=message_code.Response.fail_announce_block )
async def icx_getReceiptProof(context: Dict[str, str], **kwargs): channel = context.get('channel') channel_stub = get_channel_stub_by_channel_name(channel) tx_hash = kwargs['txHash'] response = await channel_stub.async_task().get_receipt_proof(tx_hash) return response_to_json_query(response)
async def _publish_heartbeat(): channel_stub = get_channel_stub_by_channel_name(channel_name) exception = None while ws.open: try: is_registered = await channel_stub.async_task( ).is_registered_subscriber(peer_id=peer_id) if is_registered: request = Request("node_ws_PublishHeartbeat") await ws.send(json.dumps(request)) heartbeat_time = StubCollection().conf[ ConfigKey.WS_HEARTBEAT_TIME] await asyncio.sleep(heartbeat_time) continue raise RuntimeError("Unregistered") except Exception as e: exception = e traceback.print_exc() break if not exception: exception = ConnectionError("Connection closed.") request = Request("node_ws_PublishHeartbeat", error=str(exception)) await ws.send(json.dumps(request)) raise exception
async def icx_getReceiptProof(**kwargs): channel = kwargs['context']['channel'] channel_stub = get_channel_stub_by_channel_name(channel) tx_hash = kwargs['txHash'] response = await channel_stub.async_task().get_receipt_proof(tx_hash) return response_to_json_query(response)
async def publish_new_block(ws, channel_name, height, peer_id): exception = None error_code = None channel_stub = get_channel_stub_by_channel_name(channel_name) try: while ws.open: new_block_dumped, confirm_info_bytes = await \ channel_stub.async_task().announce_new_block(subscriber_block_height=height, subscriber_id=peer_id) new_block: dict = json.loads(new_block_dumped) confirm_info = confirm_info_bytes.decode('utf-8') request = Request("node_ws_PublishNewBlock", block=new_block, confirm_info=confirm_info) Logger.debug(f"node_ws_PublishNewBlock: {request}") await ws.send(json.dumps(request)) height += 1 except exceptions.ConnectionClosed as e: exception = e error_code = message_code.Response.fail_connection_closed except Exception as e: exception = e error_code = message_code.Response.fail_announce_block traceback.print_exc() if not exception: exception = ConnectionError("Connection closed.") await WSDispatcher.send_and_raise_exception(ws, "node_ws_PublishNewBlock", exception, error_code)
async def icx_proveTransaction(**kwargs): channel = kwargs['context']['channel'] channel_stub = get_channel_stub_by_channel_name(channel) tx_hash = kwargs['txHash'] proof = kwargs['proof'] response = await channel_stub.async_task().prove_tx(tx_hash, proof) return response_to_json_query(response)
async def channel_register(ws, channel_name: str, peer_id: str): channel_stub = get_channel_stub_by_channel_name(channel_name) approved = await channel_stub.async_task().register_subscriber(peer_id=peer_id) if not approved: raise RuntimeError("This peer can no longer take more subscribe requests.") Logger.debug(f"register subscriber: {peer_id}")
async def rep_getListByHash(**kwargs): channel = kwargs['context']['channel'] channel_stub = get_channel_stub_by_channel_name(channel) request = convert_params(kwargs, RequestParamType.get_reps_by_hash) reps_hash = request.get('repsHash') reps = await channel_stub.async_task().get_reps_by_hash(reps_hash=reps_hash) Logger.debug(f"reps_hash: {reps_hash}, reps: {reps}") response = [{'address': rep['id'], 'p2pEndpoint': rep['p2pEndpoint']} for rep in reps] return response_to_json_query(response)
async def node_AnnounceConfirmedBlock(**kwargs): try: channel = kwargs['context']['channel'] del kwargs['context'] channel = channel if channel is not None else kwargs['channel'] except KeyError: channel = kwargs['channel'] block, commit_state = kwargs['block'], kwargs.get('commit_state', "{}") channel_stub = get_channel_stub_by_channel_name(channel) response_code = await channel_stub.async_task().announce_confirmed_block(block.encode('utf-8'), commit_state) return {"response_code": response_code, "message": message_code.get_response_msg(response_code)}
async def publish_unregister(ws, channel_name, peer_id, force: bool = False): call_method = WSDispatcher.PUBLISH_HEARTBEAT if force: # unregister due to subscribe limit signal = True error_code = message_code.Response.fail_subscribe_limit else: channel_stub = get_channel_stub_by_channel_name(channel_name) signal = await channel_stub.async_task().wait_for_unregister_signal(peer_id) error_code = message_code.Response.fail_connect_to_leader if signal: await WSDispatcher.send_exception( ws, call_method, exception=ConnectionError("Unregistered"), error_code=error_code)
async def _publish_new_block(): nonlocal height channel_stub = get_channel_stub_by_channel_name(channel_name) try: while ws.open: new_block: dict = json.loads( await channel_stub.async_task().announce_new_block(subscriber_block_height=height) ) Logger.debug(f"publish_new_block: {new_block}") request = Request("node_ws_PublishNewBlock", block=new_block) await ws.send(json.dumps(request)) height += 1 except Exception as e: traceback.print_exc() raise e
def __init__(self, channel_name: str, peer_id: str, remote_target: str): self._peer_id = peer_id self._remote_target = remote_target self._channel_stub = get_channel_stub_by_channel_name(channel_name)
async def channel_unregister(ws, channel_name: str, peer_id: str): channel_stub = get_channel_stub_by_channel_name(channel_name) await channel_stub.async_task().unregister_subscriber(peer_id=peer_id) Logger.debug(f"unregister subscriber: {peer_id}")
async def node_getCitizens(**kwargs): channel = kwargs['context']['channel'] channel_stub = get_channel_stub_by_channel_name(channel) citizens: List[Dict[ str, str]] = await channel_stub.async_task().get_citizens() return {"citizens": citizens}
async def node_getCitizens(context: Dict[str, str], **kwargs): channel = context.get('channel') channel_stub = get_channel_stub_by_channel_name(channel) citizens: List[Dict[ str, str]] = await channel_stub.async_task().get_citizens() return {"citizens": citizens}