def setUp(self): super(TestJobHandler, self).setUp() self.sleep_patch = mock.patch('gevent.sleep') self.sleep_mock = self.sleep_patch.start() self.logger = mock.Mock() self.amqp_client = mock.Mock() self.message = mock.Mock() self.job_template_name = ['test-job'] self.job_input = {'key1': 'value1', 'key2': 'value2'} self.device_list = ['device1'] self.api_server_config = { 'ips': ["1.2.3.4"], 'port': "8082", 'username': "******", 'password': "******", 'tenant': "default", 'use_ssl': False } self.args = AttrDict({ 'api_server_ip': '127.0.0.1', 'admin_user': '******', 'admin_password': '******', 'admin_tenant_name': 'test', 'api_server_port': 8082, 'api_server_use_ssl': False }) self.job_handler = JobHandler(self.job_template_name, self.job_input, self.device_list, self.api_server_config, self.logger, self.amqp_client, self.args)
def device_send(self, job_template, job_input, is_delete, retry): config_str = json.dumps(job_input, sort_keys=True) self.push_config_state = PushConfigState.PUSH_STATE_IN_PROGRESS start_time = None config_size = 0 forced_cfg_push = self.physical_router.forced_cfg_push try: config_size = len(config_str) current_config_hash = md5(config_str).hexdigest() if self.last_config_hash is None or ( current_config_hash != self.last_config_hash or forced_cfg_push): self._logger.info( "Config push for %s(%s) using job template %s, " "forced_push %s" % (self.physical_router.name, self.physical_router.uuid, str(job_template), forced_cfg_push)) self._logger.debug( "Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) device_manager = DeviceManager.get_instance() job_handler = JobHandler( job_template, job_input, [self.physical_router.uuid], device_manager.get_api_server_config(), self._logger, device_manager._amqp_client, self.physical_router.transaction_id, self.physical_router.transaction_descr, device_manager._args) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push(**device_manager.get_job_status_config()) end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str(end_time - start_time) self.last_config_hash = current_config_hash else: self._logger.debug("not pushing since no config change" " detected") self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, repr(e))) self._logger.error("Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str(time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def device_send(self, job_template, job_input, is_delete, retry): config_str = json.dumps(job_input, sort_keys=True) self.push_config_state = PushConfigState.PUSH_STATE_IN_PROGRESS start_time = None config_size = 0 try: config_size = len(config_str) current_config_hash = md5(config_str).hexdigest() if self.last_config_hash is None or\ current_config_hash != self.last_config_hash: self._logger.info("Config push for %s(%s) using job template %s" % (self.physical_router.name, self.physical_router.uuid, str(job_template))) self._logger.debug("Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) device_manager = DeviceManager.get_instance() job_handler = JobHandler(job_template, job_input, None if is_delete else [self.physical_router.uuid], device_manager.get_api_server_config(), self._logger, device_manager._amqp_client, device_manager._args) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push(**device_manager.get_job_status_config()) end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( end_time - start_time) self.last_config_hash = current_config_hash else: self._logger.debug("not pushing since no config change" " detected") self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, repr(e))) self._logger.error("Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def device_send(self, job_template, job_input, is_delete, retry): config_str = json.dumps(job_input, sort_keys=True) self.push_config_state = PushConfigState.PUSH_STATE_IN_PROGRESS start_time = None config_size = 0 try: config_size = len(config_str) current_config_hash = md5(config_str).hexdigest() if self.last_config_hash is None or\ current_config_hash != self.last_config_hash: self._logger.info("config push for %s(%s) using job template %s" % (self.physical_router.name, self.physical_router.uuid, str(job_template))) self._logger.debug("playbook send message: %s" % json.dumps(job_input, indent=4, sort_keys=True)) device_manager = DeviceManager.get_instance() job_handler = JobHandler(job_template, job_input, None if is_delete else [self.physical_router.uuid], device_manager.get_analytics_config(), device_manager.get_vnc(), self._logger) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push() end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( end_time - start_time) self.last_config_hash = current_config_hash else: self._logger.debug("not pushing since no config change" " detected") self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, e.message)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def redo_regular_job(job_id): """ запускает выполнение задачи с заданным job_id :param job_id: :return: """ JobHandler(job_id)
def start_job(self): try: # create job UVE and log msg = "Starting execution for job with template id %s" \ " and execution id %s" self._logger.debug(msg) # read the job template object job_template = self.job_utils.read_job_template() # spawn job greenlets job_handler = JobHandler(self._logger, self._vnc_api, job_template, self.job_execution_id, self.job_data, self.job_params, self.job_utils, self.device_json, self.auth_token) result_handler = JobResultHandler(job_template, self.job_execution_id, self._logger, self.job_utils) if job_template.get_job_template_multi_device_job(): self.handle_multi_device_job(job_handler, result_handler) else: self.handle_single_job(job_handler, result_handler) timestamp = strftime("%Y-%m-%d %H:%M:%S", gmtime()) result_handler.create_job_summary_log(timestamp) except JobException as e: self._logger.error("Job Exception recieved: %s" % e.msg) self._logger.error("%s" % traceback.print_stack()) except Exception as e: self._logger.error("Error while executing job %s " % repr(e)) self._logger.error("%s" % traceback.print_stack())
def do_regular_job(job_id, task_type, arguments, manager_type): """ выполнение работы в нормальных условия, когда записи с таким айди нет, создает новую запись в БД и запускает работу @job_id :param job_id: id задания :param task_type: тип задачи :param arguments: словарь аргументов, файлы и пути к ним :param manager_type: тип вызвавшего менеджера локальный или по сети "local" или "net" :return: void """ db = BaseDB(conf_dict) insert_tuple = ( job_id, 'processing', 0, 'step_1', ' '.join(map(str, arguments)), task_type, manager_type, '', datetime.datetime.now().strftime(DATE_FORMAT), '', ) db.insert_into_table(insert_tuple) with JobHandler(job_id, conf_dict) as job: job.run_job()
def start_job(self): try: # create job UVE and log msg = "Starting execution for job with template id %s" \ " and execution id %s" % (self.job_template_id, self.job_execution_id) self._logger.debug(msg) self.result_handler = JobResultHandler(self.job_template_id, self.job_execution_id, self._logger, self.job_utils, self.job_log_utils) # read the job template object job_template = self.job_utils.read_job_template() timestamp = int(round(time.time() * 1000)) self.job_log_utils.send_job_execution_uve(job_template.fq_name, self.job_execution_id, timestamp, 0) self.job_log_utils.send_job_log(job_template.fq_name, self.job_execution_id, msg, JobStatus.STARTING.value, timestamp=timestamp) # spawn job greenlets job_handler = JobHandler(self._logger, self._vnc_api, job_template, self.job_execution_id, self.job_data, self.job_params, self.job_utils, self.device_json, self.auth_token, self.job_log_utils, self.sandesh_args) if job_template.get_job_template_multi_device_job(): self.handle_multi_device_job(job_handler, self.result_handler) else: self.handle_single_job(job_handler, self.result_handler) # create job completion log and update job UVE self.result_handler.create_job_summary_log(job_template.fq_name) # in case of failures, exit the job manager process with failure if self.result_handler.job_result_status == JobStatus.FAILURE: sys.exit(self.result_handler.job_summary_message) except JobException as e: self._logger.error("Job Exception recieved: %s" % e.msg) self._logger.error("%s" % traceback.print_stack()) self.result_handler.update_job_status(JobStatus.FAILURE, e.msg) self.result_handler.create_job_summary_log(job_template.fq_name) sys.exit(e.msg) except Exception as e: self._logger.error("Error while executing job %s " % repr(e)) self._logger.error("%s" % traceback.print_stack()) self.result_handler.update_job_status(JobStatus.FAILURE, e.message) self.result_handler.create_job_summary_log(job_template.fq_name) sys.exit(e.message) finally: # need to wait for the last job log and uve update to complete # via sandesh time.sleep(5)
def redo_regular_job(job_id): """ запускает выполнение задачи с заданным job_id :param job_id: :return: """ with JobHandler(job_id, conf_dict) as job: job.run_job()
class TestJobHandler(MockServerMixin): job_handler = JobHandler('96e2154893e4610', 1, 1) urls = [ 'https://www.goodurl.com/image.png', 'https://www.goodurl.com', ] def test_submit(self): new_job = self.job_handler.submit(self.urls) assert self.job_handler.jobs.get(new_job['id'], None) def test_process_concurrently(self): self.job_handler.reset() new_job = self.job_handler._make_job(self.urls) job = self.job_handler._process_concurrently(new_job) # After processing, jbo fields should indicate a completion. assert job['id'] == new_job['id'] assert job['created'] == new_job['created'] assert job['finished'] is not None assert job['status'] == 'complete' # _process_concurrently manipulates the job in place. assert job == new_job def test_handle_futures(self): self.job_handler.reset() new_job = self.job_handler._make_job(self.urls) func = self.job_handler._process_image_url with futures.ThreadPoolExecutor(3) as executor: to_do = conc.submit_to_executor(executor, func, self.urls) # After completion, there should be no more pending urls # The bad url should fail and the image url should succeed. job = self.job_handler._handle_futures(new_job, to_do) assert job['uploaded']['pending'] == [] assert job['uploaded']['complete'] == ['https://i.imgur.com/0yco6KM.gif'] assert job['uploaded']['fail'] == ['https://www.goodurl.com'] assert self.job_handler.images == ['https://i.imgur.com/0yco6KM.gif'] # _handle_futures manipulates the job in place. assert job == new_job def test_process_image_url(self): # A good url should result in a imgur link link = self.job_handler._process_image_url(self.urls[0]) assert link == 'https://i.imgur.com/0yco6KM.gif' # A bad url should result in an exception with pytest.raises(IOError): link = self.job_handler._process_image_url(self.urls[1]) def test_upload_to_imgur(self): valid_base64 = 'dGhpcyBpcyBiYXNlIDY0' invalid_base64 = '$%^&' # Given a valid base64 string, the request should be made. resp = self.job_handler._upload_to_imgur(valid_base64) assert resp.status_code == 200 # Otherwise raise an exception before making the request to imgur. with pytest.raises(ValueError): resp = self.job_handler._upload_to_imgur(invalid_base64)
def setUp(self): super(TestJobHandler, self).setUp() self.post_patch = mock.patch( 'opserver_util.OpServerUtils.post_url_http') self.sleep_patch = mock.patch('gevent.sleep') self.post_mock = self.post_patch.start() self.sleep_mock = self.sleep_patch.start() self.vnc_api = mock.Mock() self.logger = mock.Mock() self.job_type = ['test-job'] self.job_input = {'key1': 'value1', 'key2': 'value2'} self.device_list = ['device1'] self.analytic_config = {'ip': '1.2.3.4', 'port': '8082'} self.job_handler = JobHandler(self.job_type, self.job_input, self.device_list, self.analytic_config, self.vnc_api, self.logger)
def device_send(self, job_template, job_input, retry): config_str = json.dumps(job_input) self.push_config_state = PushConfigState.PUSH_STATE_INIT start_time = None config_size = 0 try: self._logger.debug("playbook send message: %s" % config_str) config_size = len(config_str) device_manager = DeviceManager.get_instance() job_handler = JobHandler(job_template, job_input, [self.physical_router.uuid], device_manager.get_analytics_config(), device_manager.get_vnc(), self._logger) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push() end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( end_time - start_time) self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, e.message)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def main(client_id, num_threads, conc_reqs): app = Flask(__name__) api = Api(app) # This collects the defined resources automatically as new ones are defined. resources = ((obj, obj.URLs) for _, obj in inspect.getmembers( sys.modules[__name__], inspect.isclass) if obj.__module__ is __name__) job_handler = JobHandler(client_id, num_threads, conc_reqs) for resource, urls in resources: api.add_resource(resource, *urls, resource_class_args=(job_handler, )) app.run(debug=False, host='0.0.0.0')
def main(): global job_generator, connection config = parse_config() connection = connect_db(config) event_handler = ResultHandler(connection) job_generator = JobHandler(connection, event_handler) try: eventlet = gevent.spawn(event_handler.result_queue_handler) joblet = gevent.spawn(job_generator.job_updater) gevent.joinall([joblet, eventlet]) except gevent.GreenletExit as err: logger.warning(err) except Exception as err: logger.warning(err)
def start_job(self): try: # create job UVE and log msg = "Starting execution for job with template id %s" \ " and execution id %s" self._logger.debug(msg) timestamp = strftime("%Y-%m-%d %H:%M:%S", gmtime()) self.job_utils.send_job_execution_uve(timestamp, 0) self.job_utils.send_job_log(msg, JobStatus.STARTING, timestamp=timestamp) # read the job template object job_template = self.job_utils.read_job_template() # spawn job greenlets job_handler = JobHandler(self._logger, self._vnc_api, job_template, self.job_execution_id, self.job_data, self.job_params, self.job_utils) result_handler = JobResultHandler(job_template, self.job_execution_id, self._logger, self.job_utils) if job_template.get_job_template_multi_device_job(): self.handle_multi_device_job(job_handler, result_handler) else: self.handle_single_job(job_handler, result_handler) # update job uve timestamp = strftime("%Y-%m-%d %H:%M:%S", gmtime()) self.job_utils.send_job_execution_uve(timestamp, 100) result_handler.create_job_summary_log(timestamp) except JobException as e: self.mark_job_failure(e.message, self.job_execution_id) except Exception as e: self._logger.error("Error while executing job %s " % repr(e)) self._logger.error(traceback.print_stack()) self.mark_job_failure(e.message)
class MissForestImputationSlurm(MissForestImputation): """private class, missforest subclass for SLURM machines""" def __init__(self, mf_params, rf_params, partition, n_nodes, n_cores, node_features, memory, time): super().__init__(**mf_params) self.params = rf_params self.n_nodes = n_nodes self.node_features = node_features self.handler = JobHandler(partition, n_cores, memory, time) def miss_forest_imputation(self, matrix_for_impute): self.matrix_for_impute = matrix_for_impute self.raw_fill() vari_node = self.split_var() self.previous_iter_matrix = np.copy(self.initial_guess_matrix) self.cur_iter_matrix = np.copy(self.initial_guess_matrix) cur_iter = 1 while True: if cur_iter > self.max_iter: self.result_matrix = self.previous_iter_matrix return print("iteration " + str(cur_iter)) for i in range(len(vari_node)): cur_X = self.cur_iter_matrix x_path = self.handler.tmp_X_file with open(x_path, 'wb') as tmp: pickle.dump(cur_X, tmp) for j in range(len(vari_node[i])): #Prepare the jobs cur_vari = vari_node[i][j] cur_vart = [] cur_obsi = [] cur_misi = [] for k in range(len(vari_node[i][j])): cur_vart.append(self.vart_[cur_vari[k]]) cur_obsi.append(self.obsi[cur_vari[k]]) cur_misi.append(self.misi[cur_vari[k]]) argument_path = self.handler.get_arguments_varidx_file(i, j) result_path = self.handler.get_results_varidx_file(i, j) rf = RandomForest(self.params) with open(argument_path, 'wb') as tmp: argument_object = MissForestImputationSlurmArgumentObject(rf, cur_vart, cur_vari, cur_obsi, cur_misi) pickle.dump(argument_object, tmp) with open(result_path, 'wb') as tmp: # argument_object.results.done = False pickle.dump(argument_object.results, tmp) # write job.sh and submit command_shell = self.handler.get_command_shell(x_path, argument_path, result_path) command_shell =' '.join(command_shell) with open(self.handler.shell_script_path, 'w') as tmp: tmp.writelines('#!/bin/bash\n') tmp.writelines(command_shell) command = self.handler.get_command(i, j, cur_iter) subprocess.call(command) finish = False finished_ind = [False]*len(vari_node[i]) # finished_count = 0 while finish == False: time.sleep(0.1) finish = True for j in range(len(vari_node[i])): if finished_ind[j] == True: continue cur_vari = vari_node[i][j] cur_obsi = [] cur_misi = [] for k in range(len(vari_node[i][j])): cur_obsi.append(self.obsi[cur_vari[k]]) cur_misi.append(self.misi[cur_vari[k]]) result_path = self.handler.get_results_varidx_file(i, j) try: with open(result_path,'rb') as tmp: cur_result = pickle.load(tmp) if cur_result.done == False: finish = False break else: for k in range(len(cur_vari)): self.cur_iter_matrix[cur_misi[k],cur_vari[k]] = cur_result.imp_list[k] finished_ind[j] = True # if finished_ind.count(True) > finished_count: # finished_count = finished_ind.count(True) # print(finished_count, "/", len(finished_ind), "finished!") except Exception as e: finish = False break if self.check_converge() == True: self.result_matrix = self.previous_iter_matrix return #Update the previous_iter_matrix self.previous_iter_matrix = np.copy(self.cur_iter_matrix) cur_iter = cur_iter + 1 def split_var(self): #[NODES,[JOBS,[FEATURE]],] vari_node = [] cur_node_idx = 0 cur_job_idx = 0 cur_jobs = [] cur_vari = [] for var in self.vari: cur_vari.append(var) if len(cur_vari) == self.node_features: cur_jobs.append(cur_vari) cur_vari = [] if len(cur_jobs) == self.n_nodes: vari_node.append(cur_jobs) cur_jobs = [] if len(cur_vari) > 0: cur_jobs.append(cur_vari) if len(cur_jobs) > 0: vari_node.append(cur_jobs) print(np.shape(vari_node)) return vari_node
def __init__(self, mf_params, rf_params, partition, n_nodes, n_cores, node_features, memory, time): super().__init__(**mf_params) self.params = rf_params self.n_nodes = n_nodes self.node_features = node_features self.handler = JobHandler(partition, n_cores, memory, time)
class TestJobHandler(unittest.TestCase): JOB_SUCCESS = AttrDict({ "job_status": "SUCCESS" }) JOB_FAILURE = AttrDict({ "job_status": "FAILURE" }) JOB_IN_PROGRESS = AttrDict({ "job_status": "IN_PROGRESS" }) TIMEOUT = 15 MAX_RETRIES = 30 def setUp(self): super(TestJobHandler, self).setUp() self.sleep_patch = mock.patch('gevent.sleep') self.sleep_mock = self.sleep_patch.start() self.logger = mock.Mock() self.amqp_client = mock.Mock() self.message = mock.Mock() self.job_template_name = ['test-job'] self.job_input = {'key1': 'value1', 'key2': 'value2'} self.device_list = ['device1'] self.api_server_config = { 'ips': ["1.2.3.4"], 'port': "8082", 'username': "******", 'password': "******", 'tenant': "default", 'use_ssl': False } self.args = AttrDict({ 'api_server_ip': '127.0.0.1', 'admin_user': '******', 'admin_password': '******', 'admin_tenant_name': 'test', 'api_server_port': 8082, 'api_server_use_ssl': False }) self.job_handler = JobHandler(self.job_template_name, self.job_input, self.device_list, self.api_server_config, self.logger, self.amqp_client, self.args) # end setUp def tearDown(self): super(TestJobHandler, self).tearDown() self.sleep_patch.stop() # end tearDown def test_job_executed_successfully(self): def side_effect(*_): self.assertFalse(self.job_handler._is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.STARTING) _, kwargs = self.amqp_client.add_consumer.call_args_list[0] callback = kwargs['callback'] callback(self.JOB_SUCCESS, self.message) # end side_effect self.sleep_mock.side_effect = side_effect self.assertFalse(self.job_handler._is_job_done()) self.job_handler.push(self.TIMEOUT, self.MAX_RETRIES) self.amqp_client.add_consumer.assert_called_once() self.amqp_client.publish.assert_called_once() args, kwargs = self.amqp_client.publish.call_args_list[0] job_payload = args[0] job_execution_id = job_payload.get('job_execution_id') self.assertEqual(args[1], JobHandler.JOB_REQUEST_EXCHANGE) self.assertEqual(kwargs['routing_key'], JobHandler.JOB_REQUEST_ROUTING_KEY) args, kwargs = self.amqp_client.add_consumer.call_args_list[0] self.assertEqual(args[0], JobHandler.JOB_STATUS_CONSUMER + job_execution_id) self.assertEqual(args[1], JobHandler.JOB_STATUS_EXCHANGE) self.assertEqual(kwargs['routing_key'], JobHandler.JOB_STATUS_ROUTING_KEY + job_execution_id) self.assertEqual(kwargs['auto_delete'], True) self.message.ack.assert_called_once() self.amqp_client.remove_consumer.assert_called_once() self.assertTrue(self.job_handler._is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.SUCCESS) # end test_job_executed_successfully def test_job_stays_in_progress_then_completes(self): job_statuses = [self.JOB_IN_PROGRESS, self.JOB_IN_PROGRESS, self.JOB_SUCCESS] def side_effect(*_): side_effect.counter += 1 _, kwargs = self.amqp_client.add_consumer.call_args_list[0] callback = kwargs['callback'] callback(job_statuses[side_effect.counter-1], self.message) # end side_effect side_effect.counter = 0 self.sleep_mock.side_effect = side_effect self.assertFalse(self.job_handler._is_job_done()) self.job_handler.push(self.TIMEOUT, self.MAX_RETRIES) self.amqp_client.publish.assert_called_once() self.assertEqual(side_effect.counter, 3) self.assertTrue(self.job_handler._is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.SUCCESS) # end test_job_stays_in_progress_then_completes def test_job_failed(self): job_statuses = [self.JOB_IN_PROGRESS, self.JOB_FAILURE] def side_effect(*_): side_effect.counter += 1 _, kwargs = self.amqp_client.add_consumer.call_args_list[0] callback = kwargs['callback'] callback(job_statuses[side_effect.counter-1], self.message) # end side_effect side_effect.counter = 0 self.sleep_mock.side_effect = side_effect self.assertFalse(self.job_handler._is_job_done()) self.assertRaises(Exception, self.job_handler.push, self.TIMEOUT, self.MAX_RETRIES) self.amqp_client.publish.assert_called_once() self.assertEqual(side_effect.counter, 2) self.assertTrue(self.job_handler._is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILURE) # end test_job_failed def test_execute_job_throws(self): self.assertFalse(self.job_handler._is_job_done()) self.amqp_client.publish.side_effect = \ cfgm_common.exceptions.TimeOutError(500) self.assertRaises(Exception, self.job_handler.push, self.TIMEOUT, self.MAX_RETRIES) self.amqp_client.publish.assert_called_once() self.sleep_mock.assert_not_called() self.assertTrue(self.job_handler._is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILURE) # end test_execute_job_throws def test_max_retries_done(self): job_statuses = [self.JOB_IN_PROGRESS, self.JOB_IN_PROGRESS, self.JOB_IN_PROGRESS] def side_effect(*_): side_effect.counter += 1 _, kwargs = self.amqp_client.add_consumer.call_args_list[0] callback = kwargs['callback'] callback(job_statuses[side_effect.counter-1], self.message) # end side_effect side_effect.counter = 0 self.sleep_mock.side_effect = side_effect self.assertFalse(self.job_handler._is_job_done()) self.assertRaises(Exception, self.job_handler.push, self.TIMEOUT, 3) self.amqp_client.publish.assert_called_once() self.assertEqual(side_effect.counter, 3) self.assertTrue(self.job_handler._is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILURE)
class TestJobHandler(unittest.TestCase): NO_LOG_RESPONSE = """ { "value": [] } """ JOB_LOG_RESPONSE = """ { "value": [ { "MessageTS": 12345, "MessageType": "JobLog" } ] } """ TIMEOUT = 15 def setUp(self): super(TestJobHandler, self).setUp() self.post_patch = mock.patch( 'opserver_util.OpServerUtils.post_url_http') self.sleep_patch = mock.patch('gevent.sleep') self.post_mock = self.post_patch.start() self.sleep_mock = self.sleep_patch.start() self.vnc_api = mock.Mock() self.logger = mock.Mock() self.job_type = ['test-job'] self.job_input = {'key1': 'value1', 'key2': 'value2'} self.device_list = ['device1'] self.analytic_config = {'ip': '1.2.3.4', 'port': '8082'} self.job_handler = JobHandler(self.job_type, self.job_input, self.device_list, self.analytic_config, self.vnc_api, self.logger) # end setUp def tearDown(self): super(TestJobHandler, self).tearDown() self.post_patch.stop() self.sleep_patch.stop() # end tearDown def test_job_executed_successfully(self): self.assertFalse(self.job_handler.is_job_done()) self.vnc_api.execute_job.return_value = {'job_execution_id': 'job-1'} self.post_mock.return_value = self.JOB_LOG_RESPONSE self.assertEqual(self.job_handler.get_job_status(), JobStatus.INIT) self.job_handler.push() self.vnc_api.execute_job.assert_called_with( job_template_fq_name=self.job_type, job_input=self.job_input, device_list=self.device_list) self.assertEqual(self.post_mock.call_args[0][1], 'http://1.2.3.4:8082/analytics/query') self.assertEqual(self.post_mock.call_count, 1) self.assertTrue(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.COMPLETE) self.assertEqual(self.sleep_mock.call_args_list, []) # end test_job_executed_successfully def test_job_stays_in_progress_then_completes(self): return_values = [ self.NO_LOG_RESPONSE, self.NO_LOG_RESPONSE, self.JOB_LOG_RESPONSE ] def side_effect(*_): self.assertFalse(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.IN_PROGRESS) side_effect.counter += 1 return return_values[side_effect.counter - 1] # end side_effect side_effect.counter = 0 self.assertFalse(self.job_handler.is_job_done()) self.vnc_api.execute_job.return_value = {'job_execution_id': 'job-1'} self.post_mock.side_effect = side_effect self.assertEqual(self.job_handler.get_job_status(), JobStatus.INIT) self.job_handler.push() self.vnc_api.execute_job.assert_called_with( job_template_fq_name=self.job_type, job_input=self.job_input, device_list=self.device_list) self.assertEqual(self.post_mock.call_count, 3) self.assertTrue(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.COMPLETE) self.assertEqual(self.sleep_mock.call_args_list, [mock.call(self.TIMEOUT)]) # end test_job_stays_in_progress_then_completes def test_job_failed(self): self.assertFalse(self.job_handler.is_job_done()) self.vnc_api.execute_job.return_value = {'job_execution_id': 'job-1'} self.post_mock.side_effect = [ self.NO_LOG_RESPONSE, self.JOB_LOG_RESPONSE ] self.assertEqual(self.job_handler.get_job_status(), JobStatus.INIT) self.assertRaises(Exception, self.job_handler.push) self.vnc_api.execute_job.assert_called_with( job_template_fq_name=self.job_type, job_input=self.job_input, device_list=self.device_list) self.assertEqual(self.post_mock.call_count, 2) self.assertTrue(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILED) self.assertEqual(self.sleep_mock.call_args_list, []) # end test_job_failed def test_execute_job_throws(self): self.assertFalse(self.job_handler.is_job_done()) self.vnc_api.execute_job.side_effect = \ cfgm_common.exceptions.HttpError(500, "execute-job failed") self.assertEqual(self.job_handler.get_job_status(), JobStatus.INIT) self.assertRaises(Exception, self.job_handler.push) self.vnc_api.execute_job.assert_called_with( job_template_fq_name=self.job_type, job_input=self.job_input, device_list=self.device_list) self.post_mock.assert_not_called() self.assertTrue(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILED) self.sleep_mock.assert_not_called() # end test_execute_job_throws def test_check_status_throws(self): self.assertFalse(self.job_handler.is_job_done()) self.vnc_api.execute_job.return_value = {'job_execution_id': 'job-1'} self.post_mock.side_effect = requests.exceptions.HTTPError() self.assertEqual(self.job_handler.get_job_status(), JobStatus.INIT) self.assertRaises(Exception, self.job_handler.push) self.vnc_api.execute_job.assert_called_with( job_template_fq_name=self.job_type, job_input=self.job_input, device_list=self.device_list) self.assertEqual(self.post_mock.call_count, 1) self.assertTrue(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILED) self.sleep_mock.assert_not_called() # end test_check_status_throws def test_max_retries_done(self): self.assertFalse(self.job_handler.is_job_done()) self.vnc_api.execute_job.return_value = {'job_execution_id': 'job-1'} self.post_mock.side_effect = [ self.NO_LOG_RESPONSE, self.NO_LOG_RESPONSE, self.NO_LOG_RESPONSE, self.NO_LOG_RESPONSE, self.NO_LOG_RESPONSE, self.NO_LOG_RESPONSE ] self.assertEqual(self.job_handler.get_job_status(), JobStatus.INIT) self.assertRaises(Exception, self.job_handler.push, self.TIMEOUT, 3) self.vnc_api.execute_job.assert_called_with( job_template_fq_name=self.job_type, job_input=self.job_input, device_list=self.device_list) self.assertEqual(self.post_mock.call_count, 6) self.assertTrue(self.job_handler.is_job_done()) self.assertEqual(self.job_handler.get_job_status(), JobStatus.FAILED) self.assertEqual(self.sleep_mock.call_args_list, [mock.call(self.TIMEOUT), mock.call(self.TIMEOUT)])
- bench_positions: categorizes bench players by category, then takes this number from each position to add to the final roster - path: filename of output file - output_format: takes arguments csv, pkl, or pickle. outputs dataframe in corresponding format ''' # initial processing parameters <<<<<<< HEAD base_params = {'min_year': 2000, 'max_year': 2014, 'history_steps': 7, 'min_player_games': 2, 'num_players': 9, 'path': 'output_test_ke.csv', 'bench_positions': {'Guard': 1, 'Wing': 1, 'Big': 1} ======= base_params = {'min_year': 2000, 'max_year': 2013, 'history_steps': 7, 'min_player_games': 2, 'num_players': 9, 'path': 'output_14yrs.pkl', 'bench_positions': {'Guard': 1, 'Wing': 1, 'Big': 1}, 'output_format': 'pickle' >>>>>>> origin/master } # perform additional jobs with these parameters changed additional_search_params = [] # create a list of jobs with specified parameters jobhandler = JobHandler(base_params, additional_search_params) # perform all processing jobs jobhandler.process_jobs()