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)
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: str, self_target: str = None):
self.__channel = channel
self.__self_target = self_target
self.__audience = {} # self.__audience[peer_target] = stub_manager
self.__thread_variables = dict()
self.__thread_variables[
self.THREAD_VARIABLE_PEER_STATUS] = PeerThreadStatus.normal
if conf.IS_BROADCAST_ASYNC:
self.__broadcast_run = self.__broadcast_run_async
else:
self.__broadcast_run = self.__broadcast_run_sync
self.__handler_map = {
BroadcastCommand.CREATE_TX:
self.__handler_create_tx,
BroadcastCommand.UPDATE_AUDIENCE:
self.__handler_update_audience,
BroadcastCommand.BROADCAST:
self.__handler_broadcast,
BroadcastCommand.SEND_TO_SINGLE_TARGET:
self.__handler_send_to_single_target,
}
self.__broadcast_with_self_target_methods = {
"AddTx", "AddTxList", "BroadcastVote"
}
self.stored_tx = queue.Queue()
self.__timer_service = TimerService()
def __init__(self, channel: str, self_target: str = None):
self.__channel = channel
self.__self_target = self_target
self.__audience = {} # self.__audience[peer_target] = stub_manager
if conf.IS_BROADCAST_ASYNC:
self.__broadcast_run = self.__broadcast_run_async
else:
self.__broadcast_run = self.__broadcast_run_sync
self.__handler_map = {
BroadcastCommand.CREATE_TX:
self.__handler_create_tx,
BroadcastCommand.UPDATE_AUDIENCE:
self.__handler_update_audience,
BroadcastCommand.BROADCAST:
self.__handler_broadcast,
BroadcastCommand.SEND_TO_SINGLE_TARGET:
self.__handler_send_to_single_target,
}
self.__broadcast_with_self_target_methods = {"AddTxList"}
self.tx_messages_queue: TxMessagesQueue = TxMessagesQueue()
self.__timer_service = TimerService()
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 __init__(self, channel="", self_target=""):
super().__init__()
self.__channel = channel
self.__self_target = self_target
self.__audience = {} # self.__audience[peer_target] = stub_manager
self.__audience_subscriber = {
} # self.__audience_subscribe[peer_target] = stub_manager
self.__thread_variables = dict()
self.__thread_variables[
self.THREAD_VARIABLE_PEER_STATUS] = PeerThreadStatus.normal
if conf.IS_BROADCAST_ASYNC:
self.__broadcast_run = self.__broadcast_run_async
else:
self.__broadcast_run = self.__broadcast_run_sync
self.__handler_map = {
BroadcastCommand.CREATE_TX: self.__handler_create_tx,
BroadcastCommand.CONNECT_TO_LEADER:
self.__handler_connect_to_leader,
BroadcastCommand.SUBSCRIBE: self.__handler_subscribe,
BroadcastCommand.UNSUBSCRIBE: self.__handler_unsubscribe,
BroadcastCommand.AUDIENCE_SUBSCRIBE:
self.__handler_audience_subscribe,
BroadcastCommand.AUDIENCE_UNSUBSCRIBE:
self.__handler_audience_unsubscribe,
BroadcastCommand.UPDATE_AUDIENCE: self.__handler_update_audience,
BroadcastCommand.BROADCAST: self.__handler_broadcast,
BroadcastCommand.MAKE_SELF_PEER_CONNECTION:
self.__handler_connect_to_self_peer,
BroadcastCommand.STATUS: self.__handler_status
}
self.__broadcast_with_self_target_methods = {
"AddTx", "AddTxList", "BroadcastVote"
}
self.stored_tx = queue.Queue()
self.__broadcast_pool = futures.ThreadPoolExecutor(
conf.MAX_BROADCAST_WORKERS, "BroadcastThread")
self.__broadcast_queue = queue.PriorityQueue()
self.__tx_item_helpers = {
conf.SendTxType.pickle: TxItemHelperPickle,
conf.SendTxType.json: TxItemHelperJson,
conf.SendTxType.icx: TxItemHelperIcx
}
self.__timer_service = TimerService()
def __init__(self, channel: str, self_target: str = None):
self.__channel = channel
self.__self_target = self_target
self.__audience = {} # self.__audience[peer_target] = stub_manager
self.__thread_variables = dict()
self.__thread_variables[
self.THREAD_VARIABLE_PEER_STATUS] = PeerThreadStatus.normal
if conf.IS_BROADCAST_ASYNC:
self.__broadcast_run = self.__broadcast_run_async
else:
self.__broadcast_run = self.__broadcast_run_sync
self.__handler_map = {
BroadcastCommand.CREATE_TX:
self.__handler_create_tx,
BroadcastCommand.CONNECT_TO_LEADER:
self.__handler_connect_to_leader,
BroadcastCommand.SUBSCRIBE:
self.__handler_subscribe,
BroadcastCommand.UNSUBSCRIBE:
self.__handler_unsubscribe,
BroadcastCommand.BROADCAST:
self.__handler_broadcast,
BroadcastCommand.MAKE_SELF_PEER_CONNECTION:
self.__handler_connect_to_self_peer,
}
self.__broadcast_with_self_target_methods = {
"AddTx", "AddTxList", "BroadcastVote"
}
self.stored_tx = queue.Queue()
self.__timer_service = TimerService()
def __init__(self,
group_id=None,
radio_station_ip=None,
radio_station_port=None,
public_path=None,
private_path=None,
cert_pass=None):
"""Peer는 Radio Station 에 접속하여 leader 및 다른 Peer에 대한 접속 정보를 전달 받는다.
:param group_id: Peer Group 을 구분하기 위한 ID, None 이면 Single Peer Group 이 된다. (peer_id is group_id)
conf.PEER_GROUP_ID 를 사용하면 configure 파일에 저장된 값을 group_id 로 사용하게 된다.
:param radio_station_ip: RS IP
:param radio_station_port: RS Port
:param public_path: Peer 인증서 디렉토리 경로
:param private_path: Cert Private key
:param cert_pass: Peer private key password
:return:
"""
if radio_station_ip is None:
radio_station_ip = conf.IP_RADIOSTATION
if radio_station_port is None:
radio_station_port = conf.PORT_RADIOSTATION
if public_path is None:
public_path = conf.PUBLIC_PATH
if private_path is None:
private_path = conf.PRIVATE_PATH
if cert_pass is None:
cert_pass = conf.DEFAULT_PW
util.logger.spam(f"Your Peer Service runs on debugging MODE!")
util.logger.spam(
f"You can see many terrible garbage logs just for debugging, R U Really want it?"
)
self.__send_to_process_thread = SendToProcess()
self.__radio_station_target = radio_station_ip + ":" + str(
radio_station_port)
logging.info("Set Radio Station target is " +
self.__radio_station_target)
self.__stub_to_radio_station = None
self.__level_db = None
self.__level_db_path = ""
self.__peer_id = None
self.__group_id = group_id
if self.__group_id is None and conf.PEER_GROUP_ID != "":
self.__group_id = conf.PEER_GROUP_ID
self.__common_service = None
self.__channel_manager: ChannelManager = None
self.__rest_service = None
self.__timer_service = TimerService()
# TODO peer 서비스의 .__score를 삭제, set chain code 테스트에서만 쓰인다. (검토후 제거할 것)
self.__score = None
self.__peer_target = None
self.__inner_target = None
self.__peer_port = 0
# For Send tx to leader
self.__tx_process = None
if conf.ENABLE_KMS:
rand_table = self.__get_random_table()
self.__auth = PeerAuthorization(rand_table=rand_table)
else:
self.__auth = PeerAuthorization(public_path, private_path,
cert_pass)
# gRPC service for Peer
self.__inner_service = InnerService()
self.__outer_service = OuterService()
self.__reset_voter_in_progress = False
