def __init__(self, channel, score_package, amqp_target, amqp_key): """Score service init """ loggers.get_preset().channel_name = channel loggers.get_preset().score_package = score_package loggers.get_preset().update_logger() loggers.update_other_loggers() self.score: PeerScore = None self.score_plugin = Plugins().load_score_plugin(channel) self.iiss_plugin = Plugins().load_iiss_plugin(channel) self.__peer_id: str = None self.__channel_name: str = channel StubCollection().amqp_key = amqp_key StubCollection().amqp_target = amqp_target score_queue_name = conf.SCORE_QUEUE_NAME_FORMAT.format( score_package_name=score_package, channel_name=channel, amqp_key=amqp_key) self.__inner_service = ScoreInnerService(amqp_target, score_queue_name, conf.AMQP_USERNAME, conf.AMQP_PASSWORD, score_service=self) setproctitle.setproctitle(f"{setproctitle.getproctitle()} {channel}")
async def init(self, **kwargs): """Initialize Channel Service :param kwargs: takes (peer_id, peer_port, peer_target, rest_target) within parameters :return: None """ loggers.get_preset().peer_id = kwargs.get('peer_id') loggers.get_preset().update_logger() ChannelProperty().peer_port = kwargs.get('peer_port') ChannelProperty().peer_target = kwargs.get('peer_target') ChannelProperty().rest_target = kwargs.get('rest_target') ChannelProperty().peer_id = kwargs.get('peer_id') ChannelProperty().peer_address = ExternalAddress.fromhex_address( ChannelProperty().peer_id) ChannelProperty().node_type = conf.NodeType.CitizenNode ChannelProperty().rs_target = None self.__peer_manager = PeerManager() await self.__init_peer_auth() self.__init_broadcast_scheduler() self.__init_block_manager() await self.__init_score_container() await self.__inner_service.connect(conf.AMQP_CONNECTION_ATTEMPTS, conf.AMQP_RETRY_DELAY, exclusive=True) await self.__init_sub_services()
async def init(self, peer_port, peer_target, rest_target, radio_station_target, peer_id, group_id, node_type, score_package): loggers.get_preset().peer_id = peer_id loggers.get_preset().update_logger() ChannelProperty().peer_port = peer_port ChannelProperty().peer_target = peer_target ChannelProperty().rest_target = rest_target ChannelProperty().radio_station_target = radio_station_target ChannelProperty().peer_id = peer_id ChannelProperty().group_id = group_id ChannelProperty().node_type = conf.NodeType(node_type) ChannelProperty().score_package = score_package self.__peer_manager = PeerManager(ChannelProperty().name) await self.__init_peer_auth() self.__init_broadcast_scheduler() self.__init_block_manager() await self.__init_score_container() await self.__inner_service.connect(conf.AMQP_CONNECTION_ATTEMPS, conf.AMQP_RETRY_DELAY, exclusive=True) await self.__init_sub_services() self.block_manager.init_epoch()
def __init__(self, channel_name, amqp_target, amqp_key): self.__block_manager: BlockManager = None self.__score_container: CommonSubprocess = None self.__score_info: dict = None self.__peer_auth: PeerAuthorization = None self.__peer_manager: PeerManager = None self.__broadcast_scheduler: BroadcastScheduler = None self.__radio_station_stub = None self.__consensus: Consensus = None self.__proposer: Proposer = None self.__acceptor: Acceptor = None self.__timer_service = TimerService() loggers.get_preset().channel_name = channel_name loggers.get_preset().update_logger() channel_queue_name = conf.CHANNEL_QUEUE_NAME_FORMAT.format(channel_name=channel_name, amqp_key=amqp_key) self.__inner_service = ChannelInnerService( amqp_target, channel_queue_name, conf.AMQP_USERNAME, conf.AMQP_PASSWORD, channel_service=self) logging.info(f"ChannelService : {channel_name}, Queue : {channel_queue_name}") ChannelProperty().name = channel_name ChannelProperty().amqp_target = amqp_target StubCollection().amqp_key = amqp_key StubCollection().amqp_target = amqp_target command_arguments.add_raw_command(command_arguments.Type.Channel, channel_name) command_arguments.add_raw_command(command_arguments.Type.AMQPTarget, amqp_target) command_arguments.add_raw_command(command_arguments.Type.AMQPKey, amqp_key) ObjectManager().channel_service = self
def __init__(self, channel_name, amqp_target, amqp_key, rollback=False): self.__block_manager: BlockManager = None self.__score_container: CommonSubprocess = None self.__score_info: dict = None self.__peer_auth: Signer = None self.__broadcast_scheduler: BroadcastScheduler = None self.__rs_client: RestClient = None self.__timer_service = TimerService() self.__node_subscriber: NodeSubscriber = None self._rollback: bool = rollback loggers.get_preset().channel_name = channel_name loggers.get_preset().update_logger() channel_queue_name = conf.CHANNEL_QUEUE_NAME_FORMAT.format(channel_name=channel_name, amqp_key=amqp_key) self.__inner_service = ChannelInnerService( amqp_target, channel_queue_name, conf.AMQP_USERNAME, conf.AMQP_PASSWORD, channel_service=self) logging.info(f"ChannelService : {channel_name}, Queue : {channel_queue_name}") ChannelProperty().name = channel_name ChannelProperty().amqp_target = amqp_target ChannelProperty().crep_root_hash = Hash32.fromhex(conf.CHANNEL_OPTION[channel_name].get('crep_root_hash')) StubCollection().amqp_key = amqp_key StubCollection().amqp_target = amqp_target command_arguments.add_raw_command(command_arguments.Type.Channel, channel_name) command_arguments.add_raw_command(command_arguments.Type.AMQPTarget, amqp_target) command_arguments.add_raw_command(command_arguments.Type.AMQPKey, amqp_key) ObjectManager().channel_service = self self.__state_machine = ChannelStateMachine(self)
async def init(self, peer_port, peer_target, rest_target, radio_station_target, peer_id, group_id, node_type, score_package): loggers.get_preset().peer_id = peer_id loggers.get_preset().update_logger() ChannelProperty().peer_port = peer_port ChannelProperty().peer_target = peer_target ChannelProperty().rest_target = rest_target ChannelProperty().radio_station_target = radio_station_target ChannelProperty().peer_id = peer_id ChannelProperty().group_id = group_id ChannelProperty().node_type = conf.NodeType(node_type) ChannelProperty().score_package = score_package self.__peer_manager = PeerManager(ChannelProperty().name) await self.__init_peer_auth() self.__init_broadcast_scheduler() self.__init_block_manager() self.__init_radio_station_stub() await self.__init_score_container() await self.__inner_service.connect(conf.AMQP_CONNECTION_ATTEMPS, conf.AMQP_RETRY_DELAY, exclusive=True) self.__inner_service.init_sub_services() if self.is_support_node_function(conf.NodeFunction.Vote): if conf.ENABLE_REP_RADIO_STATION: self.connect_to_radio_station() else: await self.__load_peers_from_file() # subscribe to other peers self.__subscribe_to_peer_list() self.block_manager.init_epoch() else: self.__init_node_subscriber()
async def init(self, peer_port, peer_target, rest_target, radio_station_target, peer_id, group_id, node_type, score_package): loggers.get_preset().peer_id = peer_id loggers.get_preset().update_logger() ChannelProperty().peer_port = peer_port ChannelProperty().peer_target = peer_target ChannelProperty().rest_target = rest_target ChannelProperty().radio_station_target = radio_station_target ChannelProperty().peer_id = peer_id ChannelProperty().group_id = group_id ChannelProperty().node_type = conf.NodeType(node_type) ChannelProperty().score_package = score_package self.__init_peer_auth() self.__init_block_manager() self.__init_broadcast_scheduler() self.__init_radio_station_stub() await self.__init_score_container() await self.__inner_service.connect(conf.AMQP_CONNECTION_ATTEMPS, conf.AMQP_RETRY_DELAY, exclusive=True) self.__peer_manager = PeerManager(ChannelProperty().name) if conf.CONSENSUS_ALGORITHM == conf.ConsensusAlgorithm.lft: util.logger.spam(f"init consensus !") # load consensus self.__init_consensus() # load proposer self.__init_proposer(peer_id=peer_id) # load acceptor self.__init_acceptor(peer_id=peer_id) if self.is_support_node_function(conf.NodeFunction.Vote): self.connect_to_radio_station() await self.set_peer_type_in_channel() await self.subscribe_to_radio_station() self.generate_genesis_block() if conf.CONSENSUS_ALGORITHM == conf.ConsensusAlgorithm.lft: self.__consensus.change_epoch(precommit_block=self.__block_manager. get_blockchain().last_block) self.__consensus.start() elif conf.ALLOW_MAKE_EMPTY_BLOCK: self.block_manager.block_generation_scheduler.start()
async def init(self, peer_port, peer_target, rest_target, radio_station_target, peer_id, group_id, node_type, score_package): loggers.get_preset().peer_id = peer_id loggers.get_preset().update_logger() ChannelProperty().peer_port = peer_port ChannelProperty().peer_target = peer_target ChannelProperty().rest_target = rest_target ChannelProperty().radio_station_target = radio_station_target ChannelProperty().peer_id = peer_id ChannelProperty().group_id = group_id ChannelProperty().node_type = conf.NodeType(node_type) ChannelProperty().score_package = score_package self.__peer_manager = PeerManager(ChannelProperty().name) self.__init_peer_auth() self.__init_broadcast_scheduler() self.__init_block_manager() self.__init_radio_station_stub() await self.__init_score_container() await self.__inner_service.connect(conf.AMQP_CONNECTION_ATTEMPS, conf.AMQP_RETRY_DELAY, exclusive=True) # if conf.CONSENSUS_ALGORITHM == conf.ConsensusAlgorithm.lft: # util.logger.spam(f"init consensus !") # # load consensus # self.__init_consensus() # # load proposer # self.__init_proposer(peer_id=peer_id) # # load acceptor # self.__init_acceptor(peer_id=peer_id) if self.is_support_node_function(conf.NodeFunction.Vote): if conf.ENABLE_REP_RADIO_STATION: self.connect_to_radio_station() else: await self.__load_peers_from_file() # subscribe to other peers self.__subscribe_to_peer_list() # broadcast AnnounceNewPeer to other peers # If allow broadcast AnnounceNewPeer here, complained peer can be leader again. else: self.__init_node_subscriber() self.block_manager.init_epoch()
async def set_peer_type_in_channel(self): peer_type = loopchain_pb2.PEER blockchain = self.block_manager.get_blockchain() last_block = blockchain.last_unconfirmed_block or blockchain.last_block leader_id = None if last_block and last_block.header.next_leader is not None: leader_id = last_block.header.next_leader.hex_hx() peer = self.peer_manager.get_peer(leader_id) if peer is None: leader_id = None else: self.peer_manager.set_leader_peer(peer) if leader_id is None: leader_id = self.peer_manager.get_leader_peer().peer_id logging.debug( f"channel({ChannelProperty().name}) peer_leader: {leader_id}") logger_preset = loggers.get_preset() if ChannelProperty().peer_id == leader_id: logger_preset.is_leader = True logging.debug( f"Set Peer Type Leader! channel({ChannelProperty().name})") peer_type = loopchain_pb2.BLOCK_GENERATOR else: logger_preset.is_leader = False logger_preset.update_logger() if conf.CONSENSUS_ALGORITHM == conf.ConsensusAlgorithm.lft: self.consensus.leader_id = leader_id self.block_manager.set_peer_type(peer_type)
async def set_peer_type_in_channel(self): peer_type = loopchain_pb2.PEER peer_leader = self.peer_manager.get_leader_peer( is_complain_to_rs=self.is_support_node_function( conf.NodeFunction.Vote)) logging.debug(f"channel({ChannelProperty().name}) peer_leader: " + str(peer_leader)) logger_preset = loggers.get_preset() if self.is_support_node_function( conf.NodeFunction.Vote) and ChannelProperty( ).peer_id == peer_leader.peer_id: logger_preset.is_leader = True logging.debug( f"Set Peer Type Leader! channel({ChannelProperty().name})") peer_type = loopchain_pb2.BLOCK_GENERATOR else: logger_preset.is_leader = False logger_preset.update_logger() if conf.CONSENSUS_ALGORITHM == conf.ConsensusAlgorithm.lft: self.consensus.leader_id = peer_leader.peer_id if peer_type == loopchain_pb2.BLOCK_GENERATOR: self.block_manager.set_peer_type(peer_type) self.__ready_to_height_sync(True) elif peer_type == loopchain_pb2.PEER: self.__ready_to_height_sync(False)
def __make_peer_id(self): """네트워크에서 Peer 를 식별하기 위한 UUID를 level db 에 생성한다. """ if util.channel_use_icx(conf.LOOPCHAIN_DEFAULT_CHANNEL): self.__peer_id = IcxAuthorization( conf.LOOPCHAIN_DEFAULT_CHANNEL).address else: try: uuid_bytes = bytes( self.__level_db.Get(conf.LEVEL_DB_KEY_FOR_PEER_ID)) peer_id = uuid.UUID(bytes=uuid_bytes) except KeyError: # It's first Run peer_id = None if peer_id is None: peer_id = uuid.uuid1() logging.info("make new peer_id: " + str(peer_id)) self.__level_db.Put(conf.LEVEL_DB_KEY_FOR_PEER_ID, peer_id.bytes) self.__peer_id = str(peer_id) logger_preset = loggers.get_preset() logger_preset.peer_id = self.peer_id logger_preset.update_logger() logging.info(f"run peer_id : {self.__peer_id}")
async def set_peer_type_in_channel(self): self.__ready_to_height_sync() if self.is_support_node_function(conf.NodeFunction.Vote): peer_type = loopchain_pb2.PEER blockchain = self.block_manager.get_blockchain() last_block = blockchain.last_unconfirmed_block or blockchain.last_block if last_block and last_block.header.next_leader is not None: leader_id = last_block.header.next_leader.hex_hx() self.peer_manager.set_leader_peer( self.peer_manager.get_peer(leader_id)) else: leader_id = self.peer_manager.get_leader_peer().peer_id logging.debug( f"channel({ChannelProperty().name}) peer_leader: {leader_id}") logger_preset = loggers.get_preset() if ChannelProperty().peer_id == leader_id: logger_preset.is_leader = True logging.debug( f"Set Peer Type Leader! channel({ChannelProperty().name})") peer_type = loopchain_pb2.BLOCK_GENERATOR else: logger_preset.is_leader = False logger_preset.update_logger() if conf.CONSENSUS_ALGORITHM == conf.ConsensusAlgorithm.lft: self.consensus.leader_id = leader_id if peer_type == loopchain_pb2.BLOCK_GENERATOR: self.block_manager.set_peer_type(peer_type)
def main(argv): parser = argparse.ArgumentParser() for cmd_arg_type in command_arguments.Type: cmd_arg_attr = command_arguments.attributes[cmd_arg_type] parser.add_argument(*cmd_arg_attr.names, **cmd_arg_attr.kwargs) args, unknowns = parse_args_include_unknowns(parser, argv) quick_command = get_quick_command(unknowns) if args.version: print(json.dumps(conf.ICON_VERSIONS, indent=2)) parser.exit() command_arguments.set_raw_commands(args) if args.radio_station_target == 'testnet': args.radio_station_target = conf.URL_CITIZEN_TESTNET args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_TESTNET elif args.radio_station_target == 'mainnet': args.radio_station_target = conf.URL_CITIZEN_MAINNET args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_MAINNET if args.configure_file_path: conf.Configure().load_configure_json(args.configure_file_path) if args.key_convert: key_convert() parser.exit() if args.develop: loggers.set_preset_type(loggers.PresetType.develop) else: loggers.set_preset_type(loggers.PresetType.production) logger_preset = loggers.get_preset() logger_preset.service_type = args.service_type loggers.update_preset(False) loggers.update_other_loggers() grpc_patcher.monkey_patch() async_.thread_monkey_patch() async_.concurrent_future_monkey_patch() if args.service_type in ("peer", "citizen"): start_as_peer(args) elif args.service_type == "rest": start_as_rest_server(args) elif args.service_type == "score": start_as_score(args) elif args.service_type == "channel": start_as_channel(args) elif args.service_type == "tool": start_as_tool(args, quick_command) elif args.service_type == "admin": start_as_admin(args, quick_command) else: print( f"not supported service type {args.service_type}\ncheck loopchain help.\n" ) parser.print_help()
def __make_peer_id(self, address): self.__peer_id = address logger_preset = loggers.get_preset() logger_preset.peer_id = self.peer_id logger_preset.update_logger() logging.info(f"run peer_id : {self.__peer_id}")
def _init_properties(**kwargs): """Initialize properties :param kwargs: takes (peer_id, peer_port, peer_target, rest_target) within parameters :return: None """ loggers.get_preset().peer_id = kwargs.get('peer_id') loggers.get_preset().update_logger() ChannelProperty().peer_port = kwargs.get('peer_port') ChannelProperty().peer_target = kwargs.get('peer_target') ChannelProperty().rest_target = kwargs.get('rest_target') ChannelProperty().peer_id = kwargs.get('peer_id') ChannelProperty().peer_address = ExternalAddress.fromhex_address(ChannelProperty().peer_id) ChannelProperty().node_type = conf.NodeType.CitizenNode ChannelProperty().rs_target = None
def main(argv): parser = argparse.ArgumentParser() for cmd_arg_type in command_arguments.Type: cmd_arg_attr = command_arguments.attributes[cmd_arg_type] parser.add_argument(*cmd_arg_attr.names, **cmd_arg_attr.kwargs) args = parser.parse_args(argv) command_arguments.set_raw_commands(args) if args.radio_station_target == 'testnet': args.radio_station_target = conf.URL_CITIZEN_TESTNET args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_TESTNET elif args.radio_station_target == 'mainnet': args.radio_station_target = conf.URL_CITIZEN_MAINNET args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_MAINNET if args.configure_file_path: conf.Configure().load_configure_json(args.configure_file_path) if args.develop: loggers.set_preset_type(loggers.PresetType.develop) else: loggers.set_preset_type(loggers.PresetType.production) logger_preset = loggers.get_preset() logger_preset.service_type = args.service_type loggers.update_preset(False) loggers.update_other_loggers() grpc_patcher.monkey_patch() async .thread_monkey_patch() async .concurrent_future_monkey_patch() if args.service_type == "peer": start_as_peer(args, conf.NodeType.CommunityNode) elif args.service_type == "citizen": start_as_peer(args, conf.NodeType.CitizenNode) elif args.service_type == "rs" or args.service_type == "radiostation": start_as_rs(args) elif args.service_type == "rest": start_as_rest_server(args) elif args.service_type == "rest-rs": start_as_rest_server_rs(args) elif args.service_type == "score": start_as_score(args) elif args.service_type == "channel": start_as_channel(args) elif args.service_type == "tool": start_as_tool(args) elif args.service_type == "admin": start_as_admin(args) else: print( f"not supported service type {args.service_type}\ncheck loopchain help.\n" ) os.system("python3 ./loopchain.py -h")
def __make_peer_id(self): """네트워크에서 Peer 를 식별하기 위한 UUID를 level db 에 생성한다. """ self.__peer_id = IcxAuthorization( conf.LOOPCHAIN_DEFAULT_CHANNEL).address logger_preset = loggers.get_preset() logger_preset.peer_id = self.peer_id logger_preset.update_logger() logging.info(f"run peer_id : {self.__peer_id}")
def __init__(self, radio_station_ip=None, cert_path=None, cert_pass=None, rand_seed=None): """RadioStation Init :param radio_station_ip: radioStation Ip :param cert_path: RadioStation 인증서 디렉토리 경로 :param cert_pass: RadioStation private key password """ logger_preset = loggers.get_preset() logger_preset.peer_id = "RadioStation" logger_preset.update_logger() if radio_station_ip is None: radio_station_ip = conf.IP_RADIOSTATION logging.info("Set RadioStationService IP: " + radio_station_ip) if cert_path is not None: logging.info("CA Certificate Path : " + cert_path) self.__admin_manager = AdminManager("station") self.__channel_manager = None self.__rest_service = None self.__timer_service = TimerService() # RS has two status (active, standby) active means enable outer service # standby means stop outer service and heartbeat to the other RS (active) self.__is_active = False # 인증 클래스 self.__ca = CertificateAuthorization() if cert_path is not None: # 인증서 로드 self.__ca.load_pki(cert_path, cert_pass) logging.info("Current RadioStation SECURITY_MODE : " + str(self.__ca.is_secure)) self.p2p_inner_server = None self.p2p_outer_server = None # gRPC service for Radiostation self.__outer_service = OuterService() self.__admin_service = AdminService(self.__admin_manager) # {group_id:[ {peer_id:IP} ] }로 구성된 dictionary self.peer_groups = {conf.ALL_GROUP_ID: []} # Peer의 보안을 담당 self.auth = {} ObjectManager().rs_service = self
def set_new_leader(self, new_leader_id, block_height=0): logging.info(f"SET NEW LEADER channel({ChannelProperty().name}) leader_id({new_leader_id})") # complained_leader = self.peer_manager.get_leader_peer() leader_peer = self.peer_manager.get_peer(new_leader_id, None) if block_height > 0 and block_height != self.block_manager.get_blockchain().last_block.height + 1: logging.warning(f"height behind peer can not take leader role.") return if leader_peer is None: logging.warning(f"in channel_service:set_new_leader::There is no peer by peer_id({new_leader_id})") return util.logger.spam(f"channel_service:set_new_leader::leader_target({leader_peer.target})") self_peer_object = self.peer_manager.get_peer(ChannelProperty().peer_id) self.peer_manager.set_leader_peer(leader_peer, None) peer_leader = self.peer_manager.get_leader_peer() if self_peer_object.target == peer_leader.target: loggers.get_preset().is_leader = True loggers.get_preset().update_logger() logging.debug("I'm Leader Peer!") else: loggers.get_preset().is_leader = False loggers.get_preset().update_logger() logging.debug("I'm general Peer!")
def load_properties(properties: ModuleProcessProperties, module_name): conf.set_origin_type_configurations(properties.configurations) loggers.set_preset_type(properties.logger_preset_type) loggers.update_other_loggers() loggers.set_presets(properties.logger_presets) preset = loggers.get_preset() if preset.service_type: preset.service_type += f"-{module_name}" else: preset.service_type = module_name preset.update_logger()
async def set_peer_type_in_channel(self): peer_type = loopchain_pb2.PEER leader_id = self.__block_manager.get_next_leader() utils.logger.info(f"channel({ChannelProperty().name}) peer_leader: {leader_id}") logger_preset = loggers.get_preset() if ChannelProperty().peer_id == leader_id: logger_preset.is_leader = True utils.logger.info(f"Set Peer Type Leader! channel({ChannelProperty().name})") peer_type = loopchain_pb2.BLOCK_GENERATOR else: logger_preset.is_leader = False logger_preset.update_logger() self.__block_manager.set_peer_type(peer_type)
async def reset_leader(self, new_leader_id, block_height=0): logging.info( f"RESET LEADER channel({ChannelProperty().name}) leader_id({new_leader_id})" ) complained_leader = self.peer_manager.get_leader_peer() leader_peer = self.peer_manager.get_peer(new_leader_id, None) if block_height > 0 and block_height != self.block_manager.get_blockchain( ).last_block.height + 1: logging.warning(f"height behind peer can not take leader role.") return if leader_peer is None: logging.warning( f"in peer_service:reset_leader There is no peer by peer_id({new_leader_id})" ) return util.logger.spam( f"peer_service:reset_leader target({leader_peer.target})") self_peer_object = self.peer_manager.get_peer( ChannelProperty().peer_id) self.peer_manager.set_leader_peer(leader_peer, None) peer_leader = self.peer_manager.get_leader_peer() peer_type = loopchain_pb2.PEER if self_peer_object.target == peer_leader.target: loggers.get_preset().is_leader = True loggers.get_preset().update_logger() logging.debug("Set Peer Type Leader!") peer_type = loopchain_pb2.BLOCK_GENERATOR self.block_manager.get_blockchain().reset_made_block_count() self.peer_manager.announce_new_leader( complained_leader.peer_id, new_leader_id, is_broadcast=True, self_peer_id=ChannelProperty().peer_id) else: loggers.get_preset().is_leader = False loggers.get_preset().update_logger() logging.debug("Set Peer Type Peer!") # 새 leader 에게 subscribe 하기 await self.subscribe_to_radio_station() await self.subscribe_to_peer(peer_leader.peer_id, loopchain_pb2.BLOCK_GENERATOR) # update candidate blocks self.block_manager.get_candidate_blocks().set_last_block( self.block_manager.get_blockchain().last_block) self.block_manager.set_peer_type(peer_type)
def _vote_on_enter(self): loggers.get_preset().is_leader = False loggers.get_preset().update_logger()
async def ready_tasks(): from loopchain import loggers loggers.get_preset().update_logger() loggers.update_other_loggers() logging.debug('rest_server:initialize complete.')
def _watch_on_enter(self, *args, **kwargs): loggers.get_preset().is_leader = False loggers.get_preset().update_logger() self._run_coroutine_threadsafe( self.__channel_service.block_manager.relay_all_txs()) self.__channel_service.start_block_monitoring_timer()
def _blockgenerate_on_enter(self, *args, **kwargs): loggers.get_preset().is_leader = True loggers.get_preset().update_logger() if conf.SAFE_BLOCK_BROADCAST: self.__channel_service.inner_service.notify_unregister() self.__channel_service.block_manager.start_block_generate_timer()
def _vote_on_enter(self, *args, **kwargs): loggers.get_preset().is_leader = False loggers.get_preset().update_logger()
def _blockgenerate_on_enter(self): loggers.get_preset().is_leader = True loggers.get_preset().update_logger() self.__channel_service.block_manager.start_block_generate_timer()