def serve(self,
port,
agent_pin: str = None,
amqp_target: str = None,
amqp_key: str = None,
event_for_init: multiprocessing.Event = None):
"""start func of Peer Service ===================================================================
:param port:
:param agent_pin: kms agent pin
:param amqp_target: rabbitmq host target
:param amqp_key: sharing queue key
:param event_for_init: set when peer initiates
"""
amqp_target = amqp_target or conf.AMQP_TARGET
amqp_key = amqp_key or conf.AMQP_KEY
stopwatch_start = timeit.default_timer()
self.__init_kms_helper(agent_pin)
self.__init_port(port)
self.__init_level_db()
self.__init_key_by_channel()
StubCollection().amqp_target = amqp_target
StubCollection().amqp_key = amqp_key
peer_queue_name = conf.PEER_QUEUE_NAME_FORMAT.format(amqp_key=amqp_key)
self.__outer_service = PeerOuterService()
self.__inner_service = PeerInnerService(amqp_target,
peer_queue_name,
conf.AMQP_USERNAME,
conf.AMQP_PASSWORD,
peer_service=self)
self.__channel_infos = self.__get_channel_infos()
if not self.__channel_infos:
util.exit_and_msg(
"There is no peer_list, initial network is not allowed without RS!"
)
self.__run_rest_services(port)
self.run_common_service()
self.__close_kms_helper()
stopwatch_duration = timeit.default_timer() - stopwatch_start
logging.info(
f"Start Peer Service at port: {port} start duration({stopwatch_duration})"
)
async def _serve():
await self.ready_tasks()
await self.__inner_service.connect(conf.AMQP_CONNECTION_ATTEMPS,
conf.AMQP_RETRY_DELAY,
exclusive=True)
if conf.CHANNEL_BUILTIN:
await self.serve_channels()
if event_for_init is not None:
event_for_init.set()
logging.info(f'peer_service: init complete peer: {self.peer_id}')
loop = self.__inner_service.loop
loop.create_task(_serve())
loop.add_signal_handler(signal.SIGINT, self.close)
loop.add_signal_handler(signal.SIGTERM, self.close)
try:
loop.run_forever()
finally:
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
self.__common_service.wait()
# process monitor must stop monitoring before any subprocess stop
# Monitor().stop()
logging.info("Peer Service Ended.")
if self.__rest_service is not None:
self.__rest_service.stop()
if self.__rest_proxy_server is not None:
self.__rest_proxy_server.stop()
def serve(self,
port,
agent_pin: str = None,
amqp_target: str = None,
amqp_key: str = None,
event_for_init: multiprocessing.Event = None):
"""start func of Peer Service ===================================================================
:param port:
:param agent_pin: kms agent pin
:param amqp_target: rabbitmq host target
:param amqp_key: sharing queue key
:param event_for_init: set when peer initiates
"""
amqp_target = amqp_target or conf.AMQP_TARGET
amqp_key = amqp_key or conf.AMQP_KEY
stopwatch_start = timeit.default_timer()
self._init_kms_helper(agent_pin)
self._init_port(port)
self._init_node_key()
StubCollection().amqp_target = amqp_target
StubCollection().amqp_key = amqp_key
peer_queue_name = conf.PEER_QUEUE_NAME_FORMAT.format(amqp_key=amqp_key)
self._outer_service = PeerOuterService(self)
self._inner_service = PeerInnerService(amqp_target,
peer_queue_name,
conf.AMQP_USERNAME,
conf.AMQP_PASSWORD,
peer_service=self)
self._channel_infos = conf.CHANNEL_OPTION
self._run_rest_services(port)
self._close_kms_helper()
stopwatch_duration = timeit.default_timer() - stopwatch_start
logging.info(
f"Start Peer Service at port: {port} start duration({stopwatch_duration})"
)
async def _serve():
await self.run_p2p_server()
await self.ready_tasks()
await self._inner_service.connect(conf.AMQP_CONNECTION_ATTEMPTS,
conf.AMQP_RETRY_DELAY,
exclusive=True)
if conf.CHANNEL_BUILTIN:
await self.serve_channels()
if event_for_init is not None:
event_for_init.set()
logging.info(f'init complete peer: {self.peer_id}')
loop = self._inner_service.loop
loop.create_task(_serve())
loop.add_signal_handler(signal.SIGINT, self.close)
loop.add_signal_handler(signal.SIGTERM, self.close)
try:
loop.run_forever()
finally:
loop.run_until_complete(loop.shutdown_asyncgens())
self._cleanup(loop)
loop.close()
logging.info("Peer Service Ended.")