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