def _send_measurement(self, id_measurement, measurement):
with pika.BlockingConnection(
pika.ConnectionParameters(self.event_host,
self.event_port)) as connection:
with connection.channel() as channel:
number_ready_task = len(measurement['tasks_results'])
for i, task_parameter in enumerate(
measurement['tasks_to_send']):
if i >= number_ready_task:
self.logger.info("Sending task: %s" % task_parameter)
task_description = dict()
task_description["id_measurement"] = id_measurement
task_description["task_id"] = str(uuid.uuid4())
config = Configuration.from_json(
measurement["configuration"])
task_description[
"experiment_id"] = config.experiment_id
task_description["task_name"] = self._task_name
task_description[
"time_for_run"] = self._time_for_one_task_running
task_description["Scenario"] = self._scenario
task_description["result_structure"] = self._objectives
task_description["parameters"] = task_parameter
try:
channel.basic_publish(
exchange='',
routing_key='task_queue',
body=json.dumps(task_description))
except pika.exceptions.ChannelWrongStateError as err:
if not channel.is_open:
self.logger.warning(
"Attempt to send a message after closing the connection"
)
else:
raise err
def get_default_configurations_results(self, ch, method, properties, body):
"""
Callback function for the result of default configuration
:param ch: pika.Channel
:param method: pika.spec.Basic.GetOk
:param properties: pika.spec.BasicProperties
:param body: result of measuring default configuration in bytes format
"""
default_configuration = Configuration.from_json(body.decode())
if default_configuration.status == Configuration.Status.BAD:
new_default_values = self.default_config_handler.get_new_default_config(
)
if new_default_values:
config = Configuration(new_default_values,
Configuration.Type.FROM_SELECTOR,
self.experiment.unique_id)
temp_msg = "New default configuration sampled."
self.logger.info(temp_msg)
self.sub.send('log', 'info', message=temp_msg)
self.consume_channel.basic_publish(
exchange='',
routing_key='measure_new_configuration_queue',
body=json.dumps({"configuration": config.to_json()}))
else:
self.logger.error(
"The specified default configuration is broken.")
self.stop()
self.sub.send(
'log',
'info',
message="The specified default configuration is broken.")
return
if self.experiment.is_configuration_evaluated(default_configuration):
self.experiment.default_configuration = default_configuration
self.database.update_record(
"Search_space", {"Exp_unique_ID": self.experiment.unique_id}, {
"Default_configuration":
default_configuration.get_configuration_record()
})
self.database.update_record(
"Search_space", {"Exp_unique_ID": self.experiment.unique_id}, {
"SearchspaceObject": pickle.dumps(
self.experiment.search_space)
})
temp_msg = f"Evaluated Default Configuration: {default_configuration}"
self.logger.info(temp_msg)
self.sub.send('log', 'info', message=temp_msg)
# starting main work: building model and choosing configuration for measuring
self.consume_channel.basic_publish(
exchange='', routing_key='get_worker_capacity_queue', body='')
def get_configurations_results(self, ch, method, properties, body):
"""
Callback function for the result of all Configurations except Default
:param ch: pika.Channel
:param method: pika.spec.Basic.GetOk
:param properties: pika.spec.BasicProperties
:param body: result of measuring any configuration except default in bytes format
"""
with self.conf_lock: # To be sure, that no Configuration will be added after satisfying all Stop Conditions.
configuration = Configuration.from_json(body.decode())
if not self._is_interrupted and self.experiment.is_configuration_evaluated(
configuration):
self.experiment.try_add_configuration(configuration)
temp_msg = "-- New Configuration was evaluated. Building Target System model."
self.logger.info(temp_msg)
self.sub.send('log', 'info', message=temp_msg)
self.consume_channel.basic_publish(
exchange='',
routing_key='get_worker_capacity_queue',
body='')
def measure_configurations(self, channel, method, properties, body):
"""
Callback function for the result of measuring
:param ch: pika.Channel
:param method: pika.spec.Basic.GetOk
:param properties: pika.spec.BasicProperties
:param body: result of a configurations in bytes format
"""
if os.environ.get('TEST_MODE') == 'UNIT_TEST':
result = json.loads(body)
else:
result = json.loads(body.decode())
configuration = Configuration.from_json(result["configuration"])
if configuration.status != Configuration.Status.NEW and os.environ.get(
'TEST_MODE') != 'UNIT_TEST':
tasks_to_send = result["tasks_to_send"]
tasks_results = result["tasks_results"]
for index, objective in enumerate(self._objectives):
tasks_results = error_check(tasks_results, objective,
self._expected_values_range[index],
self._objectives_data_types[index])
if self.experiment.description["OutliersDetection"]["isEnabled"]:
tasks_results = self.outlier_detectors.find_outliers_for_taskset(
tasks_results, self._objectives, [configuration],
tasks_to_send)
# Sending data to API and adding Tasks to Configuration
for parameters, task in zip(tasks_to_send, tasks_results):
if configuration.parameters == parameters:
if configuration.is_valid_task(task):
configuration.add_task(task)
if os.environ.get('TEST_MODE') != 'UNIT_TEST':
self.database.write_one_record(
"Tasks", configuration.get_task_record(task))
else:
configuration.increase_failed_tasks_number()
API().send('new',
'task',
configurations=[parameters],
results=[task])
# Evaluating configuration
if configuration.number_of_failed_tasks <= self.repeater_parameters[
'MaxFailedTasksPerConfiguration']:
needed_tasks_count = self.evaluation_by_type(configuration)
else:
needed_tasks_count = 0
configuration.status = Configuration.Status.BAD
if len(configuration.get_tasks()) == 0:
self.experiment.increment_bad_configuration_number()
configuration.disable_configuration()
current_measurement = {
str(configuration.parameters): {
'parameters': configuration.parameters,
'needed_tasks_count': needed_tasks_count,
'Finished': False
}
}
if needed_tasks_count == 0:
current_measurement[str(
configuration.parameters)]['Finished'] = True
current_measurement[str(
configuration.parameters)]['Results'] = configuration.results
tasks_to_send = []
for point in current_measurement.keys():
if not current_measurement[point]['Finished']:
for i in range(
current_measurement[point]['needed_tasks_count']):
tasks_to_send.append(
current_measurement[point]['parameters'])
self.performed_measurements += 1
if os.environ.get('TEST_MODE') != 'UNIT_TEST':
self.database.write_one_record(
"Repeater_measurements",
self.get_repeater_measurements_record())
if os.environ.get('TEST_MODE') == 'UNIT_TEST':
return configuration, needed_tasks_count
elif configuration.status == Configuration.Status.MEASURED or configuration.status == Configuration.Status.BAD:
conn_params = pika.ConnectionParameters(host=self.event_host,
port=int(self.event_port))
with pika.BlockingConnection(conn_params) as connection:
with connection.channel() as channel:
try:
if configuration.type == Configuration.Type.DEFAULT:
self._type = self.get_repeater()
channel.basic_publish(
exchange='',
routing_key=
'default_configuration_results_queue',
body=configuration.to_json())
elif configuration.type == Configuration.Type.PREDICTED or \
configuration.type == Configuration.Type.FROM_SELECTOR:
channel.basic_publish(
exchange='',
routing_key='configurations_results_queue',
body=configuration.to_json())
except pika.exceptions.ChannelWrongStateError as err:
if not channel.is_open:
self.logger.warning(
"Attempt to send a message after closing the connection"
)
else:
raise err
elif configuration.status == Configuration.Status.EVALUATED or \
configuration.status == Configuration.Status.REPEATED_MEASURING:
conn_params = pika.ConnectionParameters(host=self.event_host,
port=int(self.event_port))
with pika.BlockingConnection(conn_params) as connection:
with connection.channel() as channel:
body = json.dumps({
"configuration": configuration.to_json(),
"tasks": tasks_to_send
})
channel.basic_publish(exchange='',
routing_key='process_tasks_queue',
body=body)