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)