def Subscribe(self, request, context): """BlockGenerator 가 broadcast(unconfirmed or confirmed block) 하는 채널에 Peer 를 등록한다. :param request: :param context: :return: """ channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel if not request.peer_id or not request.peer_target: return loopchain_pb2.CommonReply( response_code=message_code.get_response_code(message_code.Response.fail_wrong_subscribe_info), message=message_code.get_response_msg(message_code.Response.fail_wrong_subscribe_info) ) channel_stub = StubCollection().channel_stubs[channel_name] peer_list = [target['peer_target'] for target in self.peer_service.channel_infos[channel_name]["peers"]] if (request.peer_target in peer_list and conf.ENABLE_CHANNEL_AUTH) or \ (request.node_type == loopchain_pb2.CommunityNode and not conf.ENABLE_CHANNEL_AUTH): channel_stub.sync_task().add_audience(peer_target=request.peer_target) util.logger.spam(f"peer_outer_service::Subscribe add_audience " f"target({request.peer_target}) in channel({request.channel})") else: logging.error(f"This target({request.peer_target}, {request.node_type}) failed to subscribe.") return loopchain_pb2.CommonReply(response_code=message_code.get_response_code(message_code.Response.fail), message=message_code.get_response_msg("Unknown type peer")) return loopchain_pb2.CommonReply(response_code=message_code.get_response_code(message_code.Response.success), message=message_code.get_response_msg(message_code.Response.success))
def Subscribe(self, request, context): """RadioStation 이 broadcast 하는 채널에 Peer 를 등록한다. :param request: SubscribeRequest :param context: :return: CommonReply """ channel = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug("Radio Station Subscription peer_id: " + str(request)) ObjectManager().rs_service.channel_manager.add_audience(channel, request.peer_target) peer: PeerInfo = ObjectManager().rs_service.channel_manager.get_peer_manager(channel).update_peer_status( peer_id=request.peer_id, peer_status=PeerStatus.connected) try: peer_dumped = peer.dump() request.peer_order = peer.order request.peer_object = peer_dumped ObjectManager().rs_service.channel_manager.get_peer_manager(channel).announce_new_peer(request) return loopchain_pb2.CommonReply( response_code=message_code.get_response_code(message_code.Response.success), message=message_code.get_response_msg(message_code.Response.success)) except Exception as e: logging.warning("Fail Peer Dump: " + str(e)) return loopchain_pb2.CommonReply(response_code=message_code.get_response_code(message_code.Response.fail), message=message_code.get_response_msg(message_code.Response.fail))
def VoteUnconfirmedBlock(self, request, context): channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel block_manager = self.peer_service.channel_manager.get_block_manager( channel_name) util.logger.spam( f"peer_outer_service:VoteUnconfirmedBlock ({channel_name})") if conf.CONSENSUS_ALGORITHM != conf.ConsensusAlgorithm.lft: if block_manager.peer_type == loopchain_pb2.PEER: # util.logger.warning(f"peer_outer_service:VoteUnconfirmedBlock ({channel_name}) Not Leader Peer!") return loopchain_pb2.CommonReply( response_code=message_code.Response.fail_no_leader_peer, message=message_code.get_response_msg( message_code.Response.fail_no_leader_peer)) logging.info("Peer vote to : " + request.block_hash + " " + str(request.vote_code) + f"from {request.peer_id}") block_manager.get_candidate_blocks().vote_to_block( request.block_hash, (False, True)[request.vote_code == message_code.Response.success_validate_block], request.peer_id, request.group_id) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def AnnounceNewLeader(self, request, context): channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel new_leader_peer = ObjectManager( ).rs_service.channel_manager.get_peer_manager(channel_name).get_peer( request.new_leader_id, None) if new_leader_peer is None: logging.warning( f"RadioStation Has No live Peer Connection(candidate reason is RS's restart)" ) logging.warning( f"RadioStation Request to Peers make Re-Connection") return loopchain_pb2.CommonReply( response_code=message_code.Response.fail_no_peer_info_in_rs, message=message_code.get_response_msg( message_code.Response.fail_no_peer_info_in_rs)) else: logging.debug(f"AnnounceNewLeader({channel_name}) " f"id({request.new_leader_id}) " f"target({new_leader_peer.target}): " + request.message) ObjectManager().rs_service.channel_manager.get_peer_manager( channel_name).set_leader_peer(peer=new_leader_peer, group_id=None) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def GetRandomTable(self, request, context): if conf.KEY_LOAD_TYPE == KeyLoadType.RANDOM_TABLE_DERIVATION: try: serialized_table = json.dumps(ObjectManager().rs_service.random_table) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message=serialized_table) except Exception as e: logging.error(f"random table serialize fail \n" f"cause {e}") return loopchain_pb2.CommonReply(response_code=message_code.Response.fail, messsage="random_table serialize fail") else: return loopchain_pb2.CommonReply(response_code=message_code.Response.fail, messsage="RadioStation KMS Policy is not enable")
def AddTx(self, request: loopchain_pb2.TxSend, context): """Add tx to Block Manager :param request: :param context: :return: """ channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel # logging.debug(f"peer_outer_service::AddTx channel({channel_name})") block_manager = self.peer_service.channel_manager.get_block_manager( channel_name) if block_manager.peer_type == loopchain_pb2.BLOCK_GENERATOR and block_manager.consensus.block is None: return loopchain_pb2.CommonReply( response_code=message_code.Response. fail_made_block_count_limited, message="this leader can't make more block") block_manager.add_tx_unloaded(request.tx) # TODO AddTx 는 성능에 민감한 구간으로 이곳에 기능과 무관한 코드를 삽입하면 성능에 영향을 줍니다. # 이 곳에서 tx_hash 를 로그로 남겨야 하면 request 에 tx_hash 를 포함해서 보내도록 코드를 수정해야 합니다. tx = pickle.loads(request.tx) # logger = sender.FluentSender('app', host=conf.MONITOR_LOG_HOST, port=conf.MONITOR_LOG_PORT) # logger.emit('follow', {'from': 'userA', 'to': 'userB'}) # logger.emit_with_time('follow', time.time(), {'from': 'userA', 'to': 'userB'}) # if not logger.emit('follow', {'from': 'userA', 'to': 'userB'}): # logging.debug('hrkim>>event_test>>>>' + str(logger.last_error)) # logger.clear_last_error() # else: # logging.debug('hrkim>>event_test>>success!!') # # logging.debug('hrkim>>event_test>>anyway passed') util.apm_event( self.peer_service.peer_id, { 'event_type': 'AddTx', 'peer_id': self.peer_service.peer_id, 'data': { 'tx_hash': tx.tx_hash, 'total_tx': block_manager.get_total_tx() } }) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def AnnounceNewPeer(self, request, context): """RadioStation에서 Broadcasting 으로 신규 피어정보를 받아온다 :param request: PeerRequest :param context: :return: """ # RadioStation To Peer logging.info('Here Comes new peer: ' + str(request)) if len(request.peer_object) > 0: peer = pickle.loads(request.peer_object) # 서버로부터 발급된 토큰 검증 # Secure 인 경우 검증에 통과하여야만 peer_list에 추가함 if self.peer_service.auth.is_secure\ and self.peer_service.auth.verify_new_peer(peer, loopchain_pb2.PEER) is False: # TODO AnnounceNewPeer 과정을 실패로 처리한다. logging.debug("New Peer Validation Fail") else: logging.debug("Add New Peer: " + str(peer.peer_id)) self.peer_service.peer_list.add_peer_object(peer) logging.debug("Try save peer list...") self.peer_service.common_service.save_peer_list( self.peer_service.peer_list) self.peer_service.show_peers() # Block generator makes a peer_manager block up when a new peer joins the network. if self.peer_service.peer_type is loopchain_pb2.BLOCK_GENERATOR: self.add_peer_manager_tx() return loopchain_pb2.CommonReply(response_code=0, message="success")
def AnnounceDeletePeer(self, request, context): logging.debug( f"AnnounceDeletePeer peer_id({request.peer_id}) group_id({request.group_id})" ) self.peer_service.peer_list.remove_peer(request.peer_id, request.group_id) return loopchain_pb2.CommonReply(response_code=0, message="success")
def NotifyLeaderBroken(self, request, context): channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug("NotifyLeaderBroken: " + request.request) ObjectManager().peer_service.rotate_next_leader(channel_name) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def AnnounceUnconfirmedBlock(self, request, context): """수집된 tx 로 생성한 Block 을 각 peer 에 전송하여 검증을 요청한다. :param request: :param context: :return: """ unconfirmed_block = pickle.loads(request.block) # logging.debug(f"#block \n" # f"peer_id({unconfirmed_block.peer_id})\n" # f"made_block_count({unconfirmed_block.made_block_count})\n" # f"block_type({unconfirmed_block.block_type})\n" # f"is_divided_block({unconfirmed_block.is_divided_block})\n") # self.peer_service.add_unconfirm_block(request.block) self.peer_service.block_manager.add_unconfirmed_block( unconfirmed_block) if unconfirmed_block.made_block_count >= conf.LEADER_BLOCK_CREATION_LIMIT \ and unconfirmed_block.block_type is BlockType.vote \ and unconfirmed_block.is_divided_block is False: self.peer_service.reset_leader(unconfirmed_block.next_leader_peer) # if unconfirmed_block.block_type is BlockType.peer_list: # peer_list_data = pickle.loads(unconfirmed_block.peer_manager) # self.peer_service.peer_manager.load(peer_list_data) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def Echo(self, request, context): """gRPC 기본 성능을 확인하기 위한 echo interface, loopchain 기능과는 무관하다. :return: request 를 message 되돌려 준다. """ return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message=request.request)
def AnnounceNewBlockForVote(self, request, context): """수집된 tx 로 생성한 Block 을 각 peer 에 전송하여 검증을 요청한다. :param request: :param context: :return: """ channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug(f"peer_outer_service::AnnounceNewBlockForVote channel({channel_name})") block: Block = pickle.loads(request.block) epoch = pickle.loads(request.epoch) logging.debug(f"#block \n" f"epoch({epoch.block_height})\n" f"prev_epoch({epoch.prev_epoch})\n" f"block_type({block.block_type})\n" f"block_hash({block.block_hash})\n" f"peer_id({block.peer_id})\n" f"block_type({block.block_type})\n") channel_stub = StubCollection().channel_stubs[channel_name] channel_stub.sync_task().announce_new_block_for_vote(block, epoch) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def AnnounceConfirmedBlock(self, request, context): """Block Generator 가 announce 하는 인증된 블록의 대한 hash 를 전달받는다. :param request: BlockAnnounce of loopchain.proto :param context: gRPC parameter :return: CommonReply of loopchain.proto """ # Peer To BlockGenerator logging.debug("AnnounceConfirmedBlock block hash: " + request.block_hash) response_code, response_msg = message_code.get_response( message_code.Response.fail_announce_block) confirmed_block = pickle.loads(request.block) logging.debug(f"block \n" f"peer_id({confirmed_block.peer_id})\n" f"made_block_count({confirmed_block.made_block_count})\n" f"is_divided_block({confirmed_block.is_divided_block})") if len(request.block) > 0: logging.warning( "AnnounceConfirmedBlock without Consensus ====================" ) # 아래의 return 값을 확인하지 않아도 예외인 경우 아래 except 에서 확인된다. self.peer_service.add_unconfirm_block(request.block) try: self.peer_service.block_manager.confirm_block(request.block_hash) response_code, response_msg = message_code.get_response( message_code.Response.success_announce_block) except (BlockchainError, BlockInValidError, BlockError) as e: logging.error("AnnounceConfirmedBlock: " + str(e)) return loopchain_pb2.CommonReply(response_code=response_code, message=response_msg)
def AnnounceNewLeader(self, request, context): new_leader_peer = self.__peer_manager.get_peer(request.new_leader_id, None) logging.debug(f"AnnounceNewLeader({request.new_leader_id})({new_leader_peer.target}): " + request.message) self.__peer_manager.set_leader_peer(new_leader_peer, None) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def AnnounceUnconfirmedBlock(self, request, context): """수집된 tx 로 생성한 Block 을 각 peer 에 전송하여 검증을 요청한다. :param request: :param context: :return: """ channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug( f"peer_outer_service::AnnounceUnconfirmedBlock channel({channel_name})" ) unconfirmed_block = pickle.loads(request.block) logging.warning("Black Peer makes Fail validate Message by intention!") vote_code, message = message_code.get_response( message_code.Response.fail_validate_block) block_vote = loopchain_pb2.BlockVote( vote_code=vote_code, channel=channel_name, message=message, block_hash=unconfirmed_block.block_hash, peer_id=ObjectManager().peer_service.peer_id, group_id=ObjectManager().peer_service.group_id) self.peer_service.common_service.broadcast("VoteUnconfirmedBlock", block_vote) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def Subscribe(self, request, context): """RadioStation 이 broadcast 하는 채널에 Peer 를 등록한다. :param request: SubscribeRequest :param context: :return: CommonReply """ channel = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug("Radio Station Subscription peer_id: " + str(request)) ObjectManager().rs_service.common_service.add_audience(request) peer = ObjectManager().rs_service.channel_manager.get_peer_manager( channel).update_peer_status(peer_id=request.peer_id, peer_status=PeerStatus.connected) try: peer_dump = pickle.dumps(peer) request.peer_order = peer.order request.peer_object = peer_dump # self.__broadcast_new_peer(request) # TODO RS subsribe 를 이용하는 경우, RS 가 재시작시 peer broadcast 가 전체로 되지 않는 문제가 있다. # peer_list 를 이용하여 broadcast 하는 구조가되면 RS 혹은 Leader 에 대한 Subscribe 구조는 유효하지 않다. # 하지만 broadcast process 는 peer_list broadcast 인 경우 사용되어지지 않는다. peer_list 에서 broadcast 하는 동안 # block 되는 구조. broadcast Process 를 peer_list 를 이용한 broadcast 에서도 활용할 수 있게 하거나. # RS 혹은 Leader 가 재시작 후에 Subscribe 정보를 복원하게 하거나. # 혹은 peer_list 가 broadcast 하여도 성능상(동시성에 있어) 문제가 없는지 보증하여야 한다. TODO TODO TODO ObjectManager().rs_service.channel_manager.get_peer_manager( channel).announce_new_peer(request) # logging.debug("get_IP_of_peers_in_group: " + str(self.__peer_manager.get_IP_of_peers_in_group())) return loopchain_pb2.CommonReply( response_code=message_code.get_response_code( message_code.Response.success), message=message_code.get_response_msg( message_code.Response.success)) except pickle.PicklingError as e: logging.warning("Fail Peer Dump: " + str(e)) return loopchain_pb2.CommonReply( response_code=message_code.get_response_code( message_code.Response.fail), message=message_code.get_response_msg( message_code.Response.fail))
def VoteUnconfirmedBlock(self, request, context): if self.peer_service.peer_type == loopchain_pb2.PEER: return loopchain_pb2.CommonReply( response_code=message_code.Response.fail_no_leader_peer, message=message_code.get_response_msg( message_code.Response.fail_no_leader_peer)) else: logging.info("Peer vote to : " + request.block_hash + " " + str(request.vote_code)) self.peer_service.block_manager.get_candidate_blocks( ).vote_to_block( request.block_hash, (False, True)[request.vote_code == message_code.Response.success_validate_block], request.peer_id, request.group_id) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def UnSubscribe(self, request, context): """BlockGenerator 의 broadcast 채널에서 Peer 를 제외한다. :param request: :param context: :return: """ self.peer_service.common_service.remove_audience( request.peer_id, request.peer_target) return loopchain_pb2.CommonReply(response_code=0, message="success")
def AddTx(self, request, context): """Add tx to Block Manager :param request: :param context: :return: """ if self.peer_service.peer_type == loopchain_pb2.BLOCK_GENERATOR \ and self.peer_service.block_manager.consensus.block is None: return loopchain_pb2.CommonReply( response_code=message_code.Response. fail_made_block_count_limited, message="this leader can't make more block") self.peer_service.block_manager.add_tx_unloaded(request.tx) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def AnnounceNewLeader(self, request, context): if not request.channel: raise Exception("peer_outer_service:AnnounceNewLeader : Channel is not defined.") logging.debug(f"AnnounceNewLeader({request.channel}): " + request.message) channel_stub = StubCollection().channel_stubs[request.channel] channel_stub.sync_task().reset_leader(request.new_leader_id) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def VoteUnconfirmedBlock(self, request, context): channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel channel_stub = StubCollection().channel_stubs[channel_name] channel_stub.sync_task().vote_unconfirmed_block( peer_id=request.peer_id, group_id=request.group_id, block_hash=request.block_hash, vote_code=request.vote_code) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def UnSubscribe(self, request, context): """RadioStation 의 broadcast 채널에서 Peer 를 제외한다. :param request: SubscribeRequest :param context: :return: CommonReply """ logging.debug("Radio Station UnSubscription peer_id: " + request.peer_target) self.__peer_manager.remove_peer(request.peer_id, request.group_id) self.__common_service.remove_audience(request.peer_id, request.peer_target) return loopchain_pb2.CommonReply(response_code=0, message="success")
def ComplainLeader(self, request, context): logging.debug("ComplainLeader: " + request.message) # TODO AnnounceComplained 메시지를 브로드 캐스트 하여 ComplainLeader 에 대한 투표를 받는다. # 수집후 AnnounceNewLeader 메시지에 ComplainLeader 투표 결과를 담아서 발송한다. # 현재 우선 AnnounceNewLeader 를 즉시 전송하게 구현한다. Leader Change 를 우선 확인하기 위한 임시 구현 self.peer_service.peer_list.announce_new_leader( request.complained_leader_id, request.new_leader_id) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def AddTxList(self, request: loopchain_pb2.TxSendList, context): """Add tx to Block Manager :param request: :param context: :return: """ util.logger.spam(f"peer_outer_service:AddTxList try validate_dumped_tx_message") channel_name = request.channel or conf.LOOPCHAIN_DEFAULT_CHANNEL StubCollection().channel_stubs[channel_name].sync_task().add_tx_list(request) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def UnSubscribe(self, request, context): """RadioStation 의 broadcast 채널에서 Peer 를 제외한다. :param request: SubscribeRequest :param context: :return: CommonReply """ channel = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug("Radio Station UnSubscription peer_id: " + request.peer_target) channel_manager = ObjectManager().rs_service.channel_manager return loopchain_pb2.CommonReply(response_code=0, message="success")
def AnnounceNewPeer(self, request, context): """RadioStation에서 Broadcasting 으로 신규 피어정보를 받아온다 :param request: PeerRequest :param context: :return: """ # RadioStation To Peer # prevent to show certificate content # logging.info('Here Comes new peer: ' + str(request)) channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel # logging.debug(f"peer outer service::AnnounceNewPeer channel({channel_name})") peer_manager = self.peer_service.channel_manager.get_peer_manager( channel_name) if len(request.peer_object) > 0: peer = pickle.loads(request.peer_object) # 서버로부터 발급된 토큰 검증 # Secure 인 경우 검증에 통과하여야만 peer_list에 추가함 # TODO KMS 확정 전까지 보류 토큰 사용 안할 가능성이 높음 # if self.peer_service.auth.is_secure\ # and self.peer_service.auth.verify_new_peer(peer, loopchain_pb2.PEER) is False: # # TODO AnnounceNewPeer 과정을 실패로 처리한다. # logging.debug("New Peer Validation Fail") # else: # logging.debug("Add New Peer: " + str(peer.peer_id)) # self.peer_service.peer_manager.add_peer(peer) # logging.debug("Try save peer list...") # self.peer_service.common_service.save_peer_list(self.peer_service.peer_manager) logging.debug("Add New Peer: " + str(peer.peer_id)) peer_manager.add_peer(peer) # broadcast the new peer to the others for adding an audience self.peer_service.common_service.add_audience(request) logging.debug("Try save peer list...") self.peer_service.channel_manager.save_peer_manager( peer_manager, channel_name) self.peer_service.show_peers(channel_name) # Block generator makes a peer_manager block up when a new peer joins the network. if self.peer_service.channel_manager.get_block_manager( channel_name).peer_type is loopchain_pb2.BLOCK_GENERATOR: # TODO leader 가 peer manager tx 를 생성하여 블록에 peer 정보를 담는다면 채널별로 peer manager 를 저장할 필요도 있지 # 않을까? 현재는 default 채널의 peer 만 announce new peer 와 peer manager tx 생성이 이뤄지고 있다. self.add_peer_manager_tx(channel_name) # util.apm_event(self.peer_service.peer_id, { # 'event_type': 'AddPeerManagerTx', # 'peer_id': self.peer_service.peer_id}) return loopchain_pb2.CommonReply(response_code=0, message="success")
def BroadcastVote(self, request, context): channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel vote: VoteMessage = VoteMessage().loads(request.vote_data) logging.debug(f"peer_outer_service.py:BroadcastVote :: channel({channel_name})") logging.info(f"Peer vote to : {vote.block_hash} / {request.vote_code} from {request.peer_id}") util.logger.spam(f"peer_outer_service.py:BroadcastVote::{vote.print_vote_message()}") channel_stub = StubCollection().channel_stubs[request.channel] channel_stub.sync_task().broadcast_vote(vote) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def ComplainLeader(self, request, context): channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug("ComplainLeader: " + request.message) # TODO AnnounceComplained 메시지를 브로드 캐스트 하여 ComplainLeader 에 대한 투표를 받는다. # 수집후 AnnounceNewLeader 메시지에 ComplainLeader 투표 결과를 담아서 발송한다. # 현재 우선 AnnounceNewLeader 를 즉시 전송하게 구현한다. Leader Change 를 우선 확인하기 위한 임시 구현 self.peer_service.channel_manager.get_peer_manager( channel_name).announce_new_leader(request.complained_leader_id, request.new_leader_id) return loopchain_pb2.CommonReply( response_code=message_code.Response.success, message="success")
def AnnounceUnconfirmedBlock(self, request, context): """수집된 tx 로 생성한 Block 을 각 peer 에 전송하여 검증을 요청한다. :param request: :param context: :return: """ channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if request.channel == '' else request.channel logging.debug(f"peer_outer_service::AnnounceUnconfirmedBlock channel({channel_name})") channel_stub = StubCollection().channel_stubs[channel_name] channel_stub.sync_task().announce_unconfirmed_block(request.block) return loopchain_pb2.CommonReply(response_code=message_code.Response.success, message="success")
def Subscribe(self, request, context): """BlockGenerator 가 broadcast(unconfirmed or confirmed block) 하는 채널에 Peer 를 등록한다. :param request: :param context: :return: """ if request.peer_id == "": return loopchain_pb2.CommonReply( response_code=message_code.get_response_code( message_code.Response.fail_wrong_subscribe_info), message=message_code.get_response_msg( message_code.Response.fail_wrong_subscribe_info)) else: self.peer_service.common_service.add_audience(request) return loopchain_pb2.CommonReply( response_code=message_code.get_response_code( message_code.Response.success), message=message_code.get_response_msg( message_code.Response.success))