def _save_atomization_in_file(self, file_name: str = ''):
"""TODO comment."""
if file_name == '':
# Check result folder exists
checkFolders(RESULTS_FOLDER)
file_name = f'{RESULTS_FOLDER}/result_atomization_{"".join(self.name_.split())}.aml'
logger.debug(
f'Storing jobs history from node {self.name_} in file {file_name}')
# Open file and write down solution
with open(f'{file_name}', 'w') as file:
# Write down pending jobs
if len(self.pending_jobs_) > 0:
file.write('PENDING\n')
for job in self.pending_jobs_:
file.write(f'{job}\n')
# Write down timeout jobs
if len(self.timeout_jobs_) > 0:
file.write('\nTIMEOUT\n')
for job in self.timeout_jobs_:
file.write(f'{job}\n')
# Write down solutioned jobs
if len(self.solved_jobs_) > 0:
file.write('\nSOLUTION\n')
for job, solution_job in self.solved_jobs_:
file.write(f'{job} : {solution_job}\n')
def run(self):
"""TODO comment."""
logger.debug(f'Run ComputingNode {self.name_}.')
# Thread to generate jobs randomly
job_calulator_thread = \
Thread(target=self._calculate_job_solution_routine)
job_calulator_thread.start()
# Wait to stop
self.cv_stop_.acquire()
self.cv_stop_.wait_for(predicate=lambda: self.stop_)
self.cv_stop_.release()
# Wait for all threads
job_calulator_thread.join()
def _save_jobs_in_file(self, file_name: str = ''):
"""TODO comment."""
if file_name == '':
# Check result folder exists
checkFolders(RESULTS_FOLDER)
file_name = f'{RESULTS_FOLDER}/solved_jobs_{"".join(self.name_.split())}.aml'
logger.debug(
f'Storing jobs history from node {self.name_} in file {file_name}')
# Open file and write down solution
with open(f'{file_name}', 'w') as file:
# Write down pending jobs
file.write('JOBS ANSWERED\n')
for job, solution_job in self.jobs_processed_:
file.write(f'{job} : {solution_job}\n')
def __init__(
self,
name,
domain=0):
"""Construct AmlNode and instantiate every internal variable."""
logger.construct(f'Constructing AmlDdsNode {name}')
# Participant Id
self.id_ = AmlNodeId()
# Internal variables
self.name_ = name
self.domain_ = domain
self.enabled_ = False
# DDS variables
self.participant_ = None
self.topic_handler_ = TopicHandler()
self.status_writer_ = None
logger.debug(f'Created AmlDdsNode {name} with id {self.id_}.')
def init(self):
"""
Construct MainNodeParticipant object.
Construct MainNodeParticipant with name and domain given by arguments.
Create DataWriter for Status topic.
"""
# Construct Participant
self.participant_ = AmlParticipant(
name=self.name_,
domain=self.domain_)
# Create Writer
self.status_writer_ = self._create_writer(
topic_name=topic_names.STATUS_TOPIC_NAME,
topic_data_type_pubsub_constructor=status.StatusPubSubType,
topic_data_type_constructor=status.Status)
# publish state
self._publish_status_data()
logger.debug(f'AmlDdsNode {self.name_} initialized in domain {self.domain_}.')
def __create_multiservice(
self,
service_name: str,
topic_data_type_data_pubsub_constructor,
topic_data_type_data_constructor,
topic_data_type_solution_pubsub_constructor,
topic_data_type_solution_constructor,
callback=None,
server=True):
"""
Create the entities needed to have a Service Server.
Check if topics and data types are already created and create them.
Create datawriter in reply_available and reply_solution
Create datareader in request and request_data
"""
""" Create every Data Type """
# Mangling
request_availability_data_type_name = topic_names.aml_topic_data_type_mangling(
service_name, TopicKind.MULTISERVICE_REQUEST_AVAILABILITY)
task_reference_data_type_name = topic_names.aml_topic_data_type_mangling(
service_name, TopicKind.MULTISERVICE_REPLY_AVAILABLE)
task_type_name = topic_names.aml_topic_data_type_mangling(
service_name, TopicKind.MULTISERVICE_TASK)
solution_data_type_name = topic_names.aml_topic_data_type_mangling(
service_name, TopicKind.MULTISERVICE_SOLUTION)
# Request Availability Data Type
self._register_data_type(
topic_data_type_name=request_availability_data_type_name,
topic_data_type_pubsub_constructor=multiservice.Multiservice_RequestAvailabilityPubSubType,
topic_data_type_constructor=multiservice.Multiservice_RequestAvailability)
# Reply Available Data Type
self._register_data_type(
topic_data_type_name=task_reference_data_type_name,
topic_data_type_pubsub_constructor=multiservice.Multiservice_TaskReferencePubSubType,
topic_data_type_constructor=multiservice.Multiservice_TaskReference)
# Task Data Type
self._register_data_type(
topic_data_type_name=task_type_name,
topic_data_type_pubsub_constructor=topic_data_type_data_pubsub_constructor,
topic_data_type_constructor=topic_data_type_data_constructor)
# Solution Type
self._register_data_type(
topic_data_type_name=solution_data_type_name,
topic_data_type_pubsub_constructor=topic_data_type_solution_pubsub_constructor,
topic_data_type_constructor=topic_data_type_solution_constructor)
""" Create every topic"""
# Mangling
request_availability_topic_name = topic_names.aml_topic_mangling(
service_name, TopicKind.MULTISERVICE_REQUEST_AVAILABILITY)
reply_available_topic_name = topic_names.aml_topic_mangling(
service_name, TopicKind.MULTISERVICE_REPLY_AVAILABLE)
task_target_topic_name = topic_names.aml_topic_mangling(
service_name, TopicKind.MULTISERVICE_TASK_TARGET)
task_topic_name = topic_names.aml_topic_mangling(
service_name, TopicKind.MULTISERVICE_TASK)
solution_topic_name = topic_names.aml_topic_mangling(
service_name, TopicKind.MULTISERVICE_SOLUTION)
# aml_request_availability_topic
aml_request_availability_topic = \
self._register_topic(
topic_name=request_availability_topic_name,
topic_data_type_name=request_availability_data_type_name)
# aml_reply_available_topic
aml_reply_available_topic = \
self._register_topic(
topic_name=reply_available_topic_name,
topic_data_type_name=task_reference_data_type_name)
# aml_task_target_topic
aml_task_target_topic = \
self._register_topic(
topic_name=task_target_topic_name,
topic_data_type_name=task_reference_data_type_name)
# aml_task_topic
aml_task_topic = \
self._register_topic(
topic_name=task_topic_name,
topic_data_type_name=task_type_name)
# aml_solution_topic
aml_solution_topic = \
self._register_topic(
topic_name=solution_topic_name,
topic_data_type_name=solution_data_type_name)
""" Create entity """
if server:
# Create Server
logger.debug(
f'Creating Server in DDS Node {self.name_} '
f'in service {service_name}.')
return AmlMultiserviceServer(
node_id=self.id_,
service_name=service_name,
aml_participant=self.participant_,
aml_reader_request_availability_topic=aml_request_availability_topic,
aml_writer_reply_available_topic=aml_reply_available_topic,
aml_reader_task_target_topic=aml_task_target_topic,
aml_reader_task_topic=aml_task_topic,
aml_writer_solution_topic=aml_solution_topic,
callback=callback)
else:
# Create Client
logger.debug(
f'Creating Client in DDS Node {self.name_} '
f'in service {service_name}.')
return AmlMultiserviceClient(
node_id=self.id_,
service_name=service_name,
aml_participant=self.participant_,
aml_writer_request_availability_topic=aml_request_availability_topic,
aml_reader_reply_available_topic=aml_reply_available_topic,
aml_writer_task_target_topic=aml_task_target_topic,
aml_writer_task_topic=aml_task_topic,
aml_reader_solution_topic=aml_solution_topic)
def __create_endpoint(
self,
topic_name: str,
topic_data_type_name=None,
topic_data_type_pubsub_constructor=None,
topic_data_type_constructor=None,
writer=True):
"""
Create a DataWriter.
Create a Publisher with one DataWriter in specific topic.
"""
""" Get Topic Data Type """
if topic_data_type_name is None:
topic_data_type_name = topic_name
# Mangling
topic_data_type_name_mangled = \
topic_names.aml_topic_data_type_mangling(
topic_data_type_name=topic_name,
topic_kind=TopicKind.PUBSUB)
# Look for it or create it in case constructor is given
# If constructor is not given, it should already exist
if topic_data_type_constructor is not None:
self._register_data_type(
topic_data_type_name_mangled,
topic_data_type_pubsub_constructor,
topic_data_type_constructor)
""" Get Topic """
# Mangling
topic_name_mangled = \
topic_names.aml_topic_mangling(
topic_name=topic_name,
topic_kind=TopicKind.PUBSUB)
# Get Topic or create it
aml_topic = \
self._register_topic(
topic_name_mangled,
topic_data_type_name_mangled)
""" Create Entity """
if writer:
# Create Writer
logger.debug(
f'Creating Writer in DDS Node {self.name_} '
f'in topic {topic_name}.')
return AmlWriter(
aml_topic=aml_topic,
aml_participant=self.participant_)
else:
# Create Reader
logger.debug(
f'Creating Reader in DDS Node {self.name_} '
f'in topic {topic_name}.')
return AmlReader(
aml_topic=aml_topic,
aml_participant=self.participant_)