def test_scheduler_manager_singleton(self):
first_instance = schedule_manager.SchedulerManager().get_scheduler()
self.assertIsInstance(first_instance, BackgroundScheduler)
second_instance = schedule_manager.SchedulerManager().get_scheduler()
self.assertIsInstance(second_instance, BackgroundScheduler)
self.assertEqual(first_instance, second_instance)
def test_on_node_leave(self, mock_task_get_all, mock_distribute_new_job):
mock_task_get_all.return_value = FAKE_TASKS
manager = schedule_manager.SchedulerManager()
manager.on_node_leave(
mock.Mock(member_id=b'fake_member_id', group_id='fake_group_id'))
self.assertEqual(mock_task_get_all.call_count, 1)
self.assertEqual(mock_distribute_new_job.call_count, len(FAKE_TASKS))
def __init__(self, ctx, task_id, storage_id, args, interval, executor):
self.ctx = ctx
self.task_id = task_id
self.storage_id = storage_id
self.args = args
self.interval = interval
self.metric_task_rpcapi = metrics_task_rpcapi.TaskAPI()
self.driver_api = driverapi.API()
self.executor = executor
self.scheduler = schedule_manager.SchedulerManager().get_scheduler()
def __init__(self, ctx, task_id, storage_id, args, interval):
# create an object of periodic task scheduler
self.ctx = ctx
self.task_id = task_id
self.storage_id = storage_id
self.args = args
self.interval = interval
self.task_rpcapi = task_rpcapi.TaskAPI()
self.scheduler = schedule_manager.SchedulerManager().get_scheduler()
self.stopped = False
self.job_ids = set()
def __init__(self, ctx, failed_task_id, storage_id, args, job_id,
retry_count, start_time, end_time, executor):
self.ctx = ctx
self.failed_task_id = failed_task_id
self.retry_count = retry_count
self.storage_id = storage_id
self.job_id = job_id
self.args = args
self.start_time = start_time
self.end_time = end_time
self.metrics_task_rpcapi = metrics_task_rpcapi.TaskAPI()
self.scheduler_instance = \
schedule_manager.SchedulerManager().get_scheduler()
self.result = TelemetryJobStatus.FAILED_JOB_STATUS_INIT
self.executor = executor
def __init__(self, service_name=None, *args, **kwargs):
super(MetricsTaskManager, self).__init__(*args, **kwargs)
scheduler = schedule_manager.SchedulerManager()
scheduler.start()
partitioner = ConsistentHashing()
partitioner.start()
partitioner.join_group()
self.watch_job_id = None
self.cleanup_job_id = None
self.group = None
self.watcher = None
self.scheduler = None
self.rpcapi = rpcapi.SubprocessAPI()
self.executor_map = {}
self.enable_sub_process = CONF.telemetry.enable_dynamic_subprocess
if self.enable_sub_process:
self.scheduler = BackgroundScheduler()
self.scheduler.start()
self.schedule_boot_jobs(self.host)
def test_on_node_join(self, mock_task_get_all, mock_distribute_new_job,
mock_remove_job, mock_get_task_executor):
node1_job_count = 0
node2_job_count = 0
for job in FAKE_TASKS:
if job['executor'] == 'node1':
node1_job_count += 1
elif job['executor'] == 'node2':
node2_job_count += 1
mock_task_get_all.return_value = FAKE_TASKS
mock_get_task_executor.return_value = 'node1'
manager = schedule_manager.SchedulerManager()
manager.on_node_join(
mock.Mock(member_id=b'fake_member_id', group_id='node1'))
self.assertEqual(mock_task_get_all.call_count, 1)
self.assertEqual(mock_distribute_new_job.call_count,
node1_job_count + node2_job_count)
self.assertEqual(mock_remove_job.call_count, node2_job_count)
self.assertEqual(mock_get_task_executor.call_count,
node1_job_count + node2_job_count)
def start(self):
super(TaskService, self).start()
schedule_manager.SchedulerManager().start()
def __init__(self, ctx):
# create an object of periodic failed task scheduler
self.scheduler = schedule_manager.SchedulerManager().get_scheduler()
self.ctx = ctx
self.stopped = False
self.job_ids = set()
def test_recover_job(self, mock_task_get_all, mock_distribute_new_job):
mock_task_get_all.return_value = FAKE_TASKS
manager = schedule_manager.SchedulerManager()
manager.recover_job()
self.assertEqual(mock_task_get_all.call_count, 1)
self.assertEqual(mock_distribute_new_job.call_count, len(FAKE_TASKS))
def test_start(self, mock_scheduler_start):
manager = schedule_manager.SchedulerManager()
manager.start()
self.assertEqual(mock_scheduler_start.call_count, 1)
manager.start()
self.assertEqual(mock_scheduler_start.call_count, 1)
def init_scheduler(self, topic, host):
scheduler = schedule_manager.SchedulerManager()
scheduler.start()
watcher = GroupMembership(topic)
watcher.start()
watcher.join_group(host)
