def setUp(self): self._scheduler = Mock() self._sla = Sla(self._scheduler) self._cluster = Cluster(name='cl') self._role = 'mesos' self._name = 'job' self._env = 'test' self._job_key = AuroraJobKey(self._cluster.name, self._role, self._env, self._name) self._min_count = 1
def setUp(self): self._scheduler = Mock() self._sla = Sla(self._scheduler) self._cluster = Cluster(name='cl') self._role = 'mesos' self._name = 'job' self._env = 'test' self._job_key = AuroraJobKey(self._cluster.name, self._role, self._env, self._name)
def setUp(self): self._scheduler = Mock() self._sla = Sla(self._scheduler) self._cluster = Cluster(name="cl") self._role = "mesos" self._name = "job" self._env = "test" self._job_key = AuroraJobKey(self._cluster.name, self._role, self._env, self._name) self._min_count = 1
class SlaTest(unittest.TestCase): def setUp(self): self._scheduler = Mock() self._sla = Sla(self._scheduler) self._cluster = Cluster(name='cl') self._role = 'mesos' self._name = 'job' self._env = 'test' self._job_key = AuroraJobKey(self._cluster.name, self._role, self._env, self._name) self._min_count = 1 def mock_get_tasks(self, tasks, response_code=None): response_code = ResponseCode.OK if response_code is None else response_code resp = Response(responseCode=response_code, messageDEPRECATED='test') resp.result = Result(scheduleStatusResult=ScheduleStatusResult(tasks=tasks)) self._scheduler.getTasksWithoutConfigs.return_value = resp def create_task(self, duration, id, host=None, name=None, prod=None): return ScheduledTask( assignedTask=AssignedTask( instanceId=id, slaveHost=host, task=TaskConfig( production=prod if prod is not None else True, jobName=name or self._name, owner=Identity(role=self._role), environment=self._env)), status=ScheduleStatus.RUNNING, taskEvents=[TaskEvent( status=ScheduleStatus.RUNNING, timestamp=(time.time() - duration) * 1000)] ) def create_tasks(self, durations): return [self.create_task(duration, index) for index, duration in enumerate(durations)] def assert_count_result(self, percentage, duration): vector = self._sla.get_job_uptime_vector(self._job_key) actual = vector.get_task_up_count(duration) assert percentage == actual, ( 'Expected percentage:%s Actual percentage:%s' % (percentage, actual) ) self.expect_task_status_call_job_scoped() def assert_uptime_result(self, expected, percentile): vector = self._sla.get_job_uptime_vector(self._job_key) try: actual = vector.get_job_uptime(percentile) except ValueError: assert expected is None, 'Unexpected error raised.' else: assert expected is not None, 'Expected error not raised.' assert expected == actual, ( 'Expected uptime:%s Actual uptime:%s' % (expected, actual) ) self.expect_task_status_call_job_scoped() def assert_wait_time_result(self, wait_time, percentile, duration, total=None): vector = self._sla.get_job_uptime_vector(self._job_key) actual = vector.get_wait_time_to_sla(percentile, duration, total) assert wait_time == actual, ( 'Expected wait time:%s Actual wait time:%s' % (wait_time, actual) ) self.expect_task_status_call_job_scoped() def assert_safe_domain_result(self, host, percentage, duration, in_limit=None, out_limit=None, grouping=DEFAULT_GROUPING): vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) result = vector.get_safe_hosts(percentage, duration, in_limit, grouping) assert 1 == len(result), ('Expected length:%s Actual length:%s' % (1, len(result))) assert host in result[0], ('Expected host:%s not found in result' % host) if out_limit: job_details = result[0][host][0] assert job_details.job.name == out_limit.job.name, ( 'Expected job:%s Actual:%s' % (out_limit.job.name, job_details.job.name) ) assert job_details.percentage == out_limit.percentage, ( 'Expected %%:%s Actual %%:%s' % (out_limit.percentage, job_details.percentage) ) assert job_details.duration == out_limit.duration, ( 'Expected duration:%s Actual duration:%s' % (out_limit.duration, job_details.duration) ) self.expect_task_status_call_cluster_scoped() def assert_probe_hosts_result(self, hosts, percent, duration): vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count, hosts) result = vector.probe_hosts(percent, duration) assert len(hosts) == len(result), ('Expected length:%s Actual length:%s' % (1, len(result))) return result def assert_probe_hosts_result_with_grouping(self, hosts, percent, duration, group_count): vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count, hosts) result = vector.probe_hosts(percent, duration, 'by_rack') assert group_count == len(result), ('Expected length:%s Actual length:%s' % (group_count, len(result))) return result def assert_probe_host_job_details(self, result, host, f_percent, safe=True, wait_time=0): job_details = None for group in result: if host in group: job_details = group[host][0] break assert job_details, ('Expected host:%s not found in result' % host) assert job_details.job.name == self._name, ( 'Expected job:%s Actual:%s' % (self._name, job_details.job.name) ) assert job_details.predicted_percentage == f_percent, ( 'Expected percentage:%s Actual:%s' % (f_percent, job_details.predicted_percentage) ) assert job_details.safe == safe, ( 'Expected safe:%s Actual:%s' % (safe, job_details.safe) ) assert job_details.safe_in_secs == wait_time, ( 'Expected safe:%s Actual:%s' % (wait_time, job_details.safe_in_secs) ) def expect_task_status_call_job_scoped(self): self._scheduler.getTasksWithoutConfigs.assert_called_once_with( TaskQuery( owner=Identity(role=self._role), environment=self._env, jobName=self._name, statuses=LIVE_STATES) ) def expect_task_status_call_cluster_scoped(self): self._scheduler.getTasksWithoutConfigs.assert_called_with(TaskQuery(statuses=LIVE_STATES)) @contextmanager def group_by_rack(self): add_grouping('by_rack', rack_grouping) yield remove_grouping('by_rack') def test_count_0(self): self.mock_get_tasks([]) self.assert_count_result(0, 0) def test_count_50(self): self.mock_get_tasks(self.create_tasks([600, 900, 100, 200])) self.assert_count_result(50, 300) def test_count_100(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400, 500])) self.assert_count_result(100, 50) def test_uptime_empty(self): self.mock_get_tasks([]) self.assert_uptime_result(0, 50) def test_uptime_0(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(None, 0) def test_uptime_10(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(400, 10) def test_uptime_50(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(200, 50) def test_uptime_99(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(100, 99) def test_uptime_100(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(None, 100) def test_wait_time_empty(self): self.mock_get_tasks([]) self.assert_wait_time_result(None, 50, 200) def test_wait_time_0(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(0, 75, 200) def test_wait_time_infeasible(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(None, 95, 200, 5) def test_wait_time_upper(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(50, 25, 450) def test_wait_time_mid(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400, 500])) self.assert_wait_time_result(50, 50, 350) def test_wait_time_lower(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400, 500])) self.assert_wait_time_result(50, 90, 150) def test_wait_time_with_total(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(150, 80, 250) def test_domain_uptime_no_tasks(self): self.mock_get_tasks([]) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) assert 0 == len(vector.get_safe_hosts(50, 400)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime_no_result(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(200, 2, 'h2', 'j1') ]) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) assert 0 == len(vector.get_safe_hosts(50, 400)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime_no_result_min_count_filtered(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(400, 2, 'h2', 'j1'), self.create_task(400, 3, 'h3', 'j1'), self.create_task(100, 1, 'h2', 'j2') ]) vector = self._sla.get_domain_uptime_vector(self._cluster, 4) assert 0 == len(vector.get_safe_hosts(10, 200)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(200, 2, 'h2', 'j1'), self.create_task(100, 1, 'h2', 'j2') ]) self.assert_safe_domain_result('h1', 50, 200) def test_domain_uptime_with_override(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(200, 2, 'h2', self._name), self.create_task(100, 1, 'h2', 'j2') ]) job_override = { self._job_key: JobUpTimeLimit(job=self._job_key, percentage=50, duration_secs=100) } self.assert_safe_domain_result('h1', 50, 400, in_limit=job_override) def test_domain_uptime_not_production(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name, False), self.create_task(200, 2, 'h2', self._name, False), self.create_task(100, 1, 'h2', self._name, False) ]) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) assert 0 == len(vector.get_safe_hosts(50, 200)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime_production_not_set(self): task = self.create_task(500, 1, 'h1', self._name) task.assignedTask.task.production = None self.mock_get_tasks([task]) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) assert 0 == len(vector.get_safe_hosts(50, 200)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime_with_grouping(self): with self.group_by_rack(): self.mock_get_tasks([ self.create_task(100, 1, 'cl-r1-h01', self._name), self.create_task(200, 3, 'cl-r2-h03', self._name), ]) self.assert_safe_domain_result('cl-r1-h01', 50, 150, grouping='by_rack') def test_domain_uptime_with_grouping_not_safe(self): with self.group_by_rack(): self.mock_get_tasks([ self.create_task(200, 1, 'cl-r1-h01', self._name), self.create_task(100, 2, 'cl-r1-h02', self._name), self.create_task(200, 3, 'cl-r2-h03', self._name), self.create_task(100, 4, 'cl-r2-h04', self._name), ]) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) assert 0 == len(vector.get_safe_hosts(50, 150, None, 'by_rack')), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_probe_hosts_no_hosts(self): self.mock_get_tasks([]) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count) assert 0 == len(vector.probe_hosts(90, 200)) def test_probe_hosts_no_tasks(self): self.mock_get_tasks([], response_code=ResponseCode.INVALID_REQUEST) vector = self._sla.get_domain_uptime_vector(self._cluster, self._min_count, hosts=['h1', 'h2']) assert 0 == len(vector.probe_hosts(90, 200)) def test_probe_hosts_no_result(self): self.mock_get_tasks([ self.create_task(100, 1, 'h3', 'j1'), self.create_task(100, 1, 'h4', 'j2') ]) vector = self._sla.get_domain_uptime_vector(self._cluster, ['h1', 'h2']) assert 0 == len(vector.probe_hosts(90, 200)) def test_probe_hosts_no_result_min_count_filtered(self): self.mock_get_tasks([ self.create_task(100, 1, 'h3', 'j1'), self.create_task(100, 1, 'h4', 'j1'), self.create_task(100, 1, 'h5', 'j1'), self.create_task(100, 1, 'h4', 'j2') ]) vector = self._sla.get_domain_uptime_vector(self._cluster, 4, ['h1']) assert 0 == len(vector.probe_hosts(50, 50)) def test_probe_hosts_safe(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(100, 2, 'h2', self._name), ]) result = self.assert_probe_hosts_result(['h1', 'h2'], 20, 100) self.assert_probe_host_job_details(result, 'h1', 50.0) self.assert_probe_host_job_details(result, 'h2', 50.0) def test_probe_hosts_not_safe(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(200, 2, 'h2', self._name), self.create_task(300, 3, 'h3', self._name), self.create_task(400, 4, 'h4', self._name), ]) result = self.assert_probe_hosts_result(['h1', 'h2', 'h3', 'h4'], 75, 300) self.assert_probe_host_job_details(result, 'h1', 50.0, False, 100) def test_probe_hosts_not_safe_infeasible(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(200, 2, 'h2', self._name), self.create_task(300, 3, 'h3', self._name), self.create_task(400, 4, 'h4', self._name), ]) result = self.assert_probe_hosts_result(['h1', 'h2', 'h3', 'h4'], 80, 300) self.assert_probe_host_job_details(result, 'h1', 50.0, False, None) def test_probe_hosts_non_prod_ignored(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name, False), self.create_task(200, 2, 'h2', self._name, False), self.create_task(300, 3, 'h3', self._name, False), self.create_task(400, 4, 'h4', self._name, False), ]) vector = self._sla.get_domain_uptime_vector(self._cluster, ['h1', 'h2']) assert 0 == len(vector.probe_hosts(90, 200)) def test_probe_hosts_with_grouping_safe(self): with self.group_by_rack(): self.mock_get_tasks([ self.create_task(100, 1, 'cl-r1-h01', self._name), self.create_task(100, 3, 'cl-r2-h03', self._name), ]) result = self.assert_probe_hosts_result_with_grouping( ['cl-r1-h01', 'cl-r2-h03'], 50, 100, 2) self.assert_probe_host_job_details(result, 'cl-r1-h01', 50.0) self.assert_probe_host_job_details(result, 'cl-r2-h03', 50.0) def test_probe_hosts_with_grouping_not_safe(self): with self.group_by_rack(): self.mock_get_tasks([ self.create_task(100, 1, 'cl-r1-h01', self._name), self.create_task(200, 2, 'cl-r1-h02', self._name), self.create_task(100, 3, 'cl-r2-h03', self._name), self.create_task(200, 4, 'cl-r2-h04', self._name), ]) result = self.assert_probe_hosts_result_with_grouping( ['cl-r1-h01', 'cl-r1-h02', 'cl-r2-h03', 'cl-r2-h04'], 50, 200, 2) self.assert_probe_host_job_details(result, 'cl-r1-h01', 25.0, False, 100) self.assert_probe_host_job_details(result, 'cl-r1-h02', 25.0, False, 100) self.assert_probe_host_job_details(result, 'cl-r2-h03', 25.0, False, 100) self.assert_probe_host_job_details(result, 'cl-r2-h04', 25.0, False, 100) def test_get_domain_uptime_vector_with_hosts(self): with patch('apache.aurora.client.api.sla.task_query', return_value=TaskQuery()) as (mock_query): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(200, 2, 'h1', 'j2'), self.create_task(200, 3, 'h2', 'j1'), self.create_task(200, 3, 'h2', 'j3'), self.create_task(200, 4, 'h3', 'j4'), self.create_task(200, 4, 'h3', 'j3'), ]) hosts = ['h1', 'h2', 'h3'] jobs = set([ AuroraJobKey(self._cluster.name, self._role, self._env, 'j1'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j2'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j3'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j4') ]) self._sla.get_domain_uptime_vector(self._cluster, self._min_count, hosts) mock_query.assert_has_calls([call(hosts=hosts), call(job_keys=jobs)], any_order=False) def test_get_domain_uptime_vector_with_hosts_no_job_tasks(self): with patch('apache.aurora.client.api.sla.task_query', return_value=TaskQuery()) as (mock_query): self.mock_get_tasks([]) self._sla.get_domain_uptime_vector(self._cluster, self._min_count, ['h1']) mock_query.assert_called_once_with(hosts=['h1']) def test_task_query(self): jobs = set([ AuroraJobKey(self._cluster.name, self._role, self._env, 'j1'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j2'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j3'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j4') ]) query = task_query(job_keys=jobs) assert len(jobs) == len(query.jobKeys), 'Expected length:%s, Actual:%s' % ( len(jobs), len(query.jobKeys) ) assert LIVE_STATES == query.statuses, 'Expected:%s, Actual:%s' % ( LIVE_STATES, query.statuses )
class SlaTest(unittest.TestCase): def setUp(self): self._scheduler = Mock() self._sla = Sla(self._scheduler) self._cluster = Cluster(name='cl') self._role = 'mesos' self._name = 'job' self._env = 'test' self._job_key = AuroraJobKey(self._cluster.name, self._role, self._env, self._name) def mock_get_tasks(self, tasks, response_code=None): response_code = ResponseCode.OK if response_code is None else response_code resp = Response(responseCode=response_code, message='test') resp.result = Result(scheduleStatusResult=ScheduleStatusResult(tasks=tasks)) self._scheduler.getTasksStatus.return_value = resp def create_task(self, duration, id, host=None, name=None): return ScheduledTask( assignedTask=AssignedTask( instanceId=id, slaveHost=host, task=TaskConfig( production=True, jobName=name or self._name, owner=Identity(role=self._role), environment=self._env)), status=ScheduleStatus.RUNNING, taskEvents=[TaskEvent( status=ScheduleStatus.STARTING, timestamp=(time.time() - duration) * 1000)] ) def create_tasks(self, durations): return [self.create_task(duration, index) for index, duration in enumerate(durations)] def assert_count_result(self, percentage, duration): vector = self._sla.get_job_uptime_vector(self._job_key) actual = vector.get_task_up_count(duration) assert percentage == actual, ( 'Expected percentage:%s Actual percentage:%s' % (percentage, actual) ) self.expect_task_status_call_job_scoped() def assert_uptime_result(self, expected, percentile): vector = self._sla.get_job_uptime_vector(self._job_key) try: actual = vector.get_job_uptime(percentile) except ValueError: assert expected is None, 'Unexpected error raised.' else: assert expected is not None, 'Expected error not raised.' assert expected == actual, ( 'Expected uptime:%s Actual uptime:%s' % (expected, actual) ) self.expect_task_status_call_job_scoped() def assert_wait_time_result(self, wait_time, percentile, duration, total=None): vector = self._sla.get_job_uptime_vector(self._job_key) actual = vector.get_wait_time_to_sla(percentile, duration, total) assert wait_time == actual, ( 'Expected wait time:%s Actual wait time:%s' % (wait_time, actual) ) self.expect_task_status_call_job_scoped() def assert_safe_domain_result(self, host, percentage, duration, in_limit=None, out_limit=None): vector = self._sla.get_domain_uptime_vector(self._cluster) result = vector.get_safe_hosts(percentage, duration, in_limit) assert 1 == len(result), ('Expected length:%s Actual length:%s' % (1, len(result))) assert host in result, ('Expected host:%s not found in result' % host) if out_limit: assert result[host][0].job.name == out_limit.job.name, ( 'Expected job:%s Actual:%s' % (out_limit.job.name, result[host][0].job.name) ) assert result[host][0].percentage == out_limit.percentage, ( 'Expected %%:%s Actual %%:%s' % (out_limit.percentage, result[host][0].percentage) ) assert result[host][0].duration == out_limit.duration, ( 'Expected duration:%s Actual duration:%s' % (out_limit.duration, result[host][0].duration) ) self.expect_task_status_call_cluster_scoped() def assert_probe_hosts_result(self, host, percent, duration, f_percent, safe=True, wait_time=0): vector = self._sla.get_domain_uptime_vector(self._cluster) result = vector.probe_hosts(percent, duration, [host]) assert 1 == len(result), ('Expected length:%s Actual length:%s' % (1, len(result))) assert host in result, ('Expected host:%s not found in result' % host) job_details = result[host][0] assert job_details.job.name == self._name, ( 'Expected job:%s Actual:%s' % (self._name, job_details.job.name) ) assert job_details.predicted_percentage == f_percent, ( 'Expected percentage:%s Actual:%s' % (f_percent, job_details.predicted_percentage) ) assert job_details.safe == safe, ( 'Expected safe:%s Actual:%s' % (safe, job_details.safe) ) assert job_details.safe_in_secs == wait_time, ( 'Expected safe:%s Actual:%s' % (wait_time, job_details.safe_in_secs) ) self.expect_task_status_call_cluster_scoped() def expect_task_status_call_job_scoped(self): self._scheduler.getTasksStatus.assert_called_once_with( TaskQuery( owner=Identity(role=self._role), environment=self._env, jobName=self._name, statuses=SLA_LIVE_STATES) ) def expect_task_status_call_cluster_scoped(self): self._scheduler.getTasksStatus.assert_called_once_with(TaskQuery(statuses=SLA_LIVE_STATES)) def test_count_0(self): self.mock_get_tasks([]) self.assert_count_result(0, 0) def test_count_50(self): self.mock_get_tasks(self.create_tasks([600, 900, 100, 200])) self.assert_count_result(50, 300) def test_count_100(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400, 500])) self.assert_count_result(100, 50) def test_uptime_empty(self): self.mock_get_tasks([]) self.assert_uptime_result(0, 50) def test_uptime_0(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(None, 0) def test_uptime_10(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(400, 10) def test_uptime_50(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(200, 50) def test_uptime_99(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(100, 99) def test_uptime_100(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_uptime_result(None, 100) def test_wait_time_empty(self): self.mock_get_tasks([]) self.assert_wait_time_result(None, 50, 200) def test_wait_time_0(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(0, 75, 200) def test_wait_time_infeasible(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(None, 95, 200, 5) def test_wait_time_upper(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(50, 25, 450) def test_wait_time_mid(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400, 500])) self.assert_wait_time_result(50, 50, 350) def test_wait_time_lower(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400, 500])) self.assert_wait_time_result(50, 90, 150) def test_wait_time_with_total(self): self.mock_get_tasks(self.create_tasks([100, 200, 300, 400])) self.assert_wait_time_result(150, 80, 250) def test_domain_uptime_no_tasks(self): self.mock_get_tasks([]) vector = self._sla.get_domain_uptime_vector(self._cluster) assert 0 == len(vector.get_safe_hosts(50, 400)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime_no_result(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(200, 2, 'h2', 'j1') ]) vector = self._sla.get_domain_uptime_vector(self._cluster) assert 0 == len(vector.get_safe_hosts(50, 400)), 'Length must be empty.' self.expect_task_status_call_cluster_scoped() def test_domain_uptime(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(200, 2, 'h2', 'j1'), self.create_task(100, 1, 'h2', 'j2') ]) self.assert_safe_domain_result('h1', 50, 200) def test_domain_uptime_with_override(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(200, 2, 'h2', self._name), self.create_task(100, 1, 'h2', 'j2') ]) job_override = { self._job_key: DomainUpTimeSlaVector.JobUpTimeLimit( job=self._job_key, percentage=50, duration_secs=100) } self.assert_safe_domain_result('h1', 50, 400, in_limit=job_override) def test_probe_hosts_no_tasks(self): self.mock_get_tasks([]) vector = self._sla.get_domain_uptime_vector(self._cluster) assert 0 == len(vector.probe_hosts(90, 200, ['h1', 'h2'])) self.expect_task_status_call_cluster_scoped() def test_probe_hosts_no_result(self): self.mock_get_tasks([ self.create_task(100, 1, 'h3', 'j1'), self.create_task(100, 1, 'h4', 'j2') ]) vector = self._sla.get_domain_uptime_vector(self._cluster) assert 0 == len(vector.probe_hosts(90, 200, ['h1', 'h2'])) self.expect_task_status_call_cluster_scoped() def test_probe_hosts_safe(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(100, 2, 'h2', self._name), ]) self.assert_probe_hosts_result('h1', 20, 100, 50.0) def test_probe_hosts_not_safe(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(200, 2, 'h2', self._name), self.create_task(300, 3, 'h3', self._name), self.create_task(400, 4, 'h4', self._name), ]) self.assert_probe_hosts_result('h1', 75, 300, 50.0, False, 100) def test_probe_hosts_not_safe_infeasible(self): self.mock_get_tasks([ self.create_task(100, 1, 'h1', self._name), self.create_task(200, 2, 'h2', self._name), self.create_task(300, 3, 'h3', self._name), self.create_task(400, 4, 'h4', self._name), ]) self.assert_probe_hosts_result('h1', 80, 300, 50.0, False, None) def test_get_domain_uptime_vector_with_hosts(self): with patch('apache.aurora.client.api.sla.task_query', return_value=TaskQuery()) as (mock_query): self.mock_get_tasks([ self.create_task(100, 1, 'h1', 'j1'), self.create_task(200, 2, 'h1', 'j2'), self.create_task(200, 3, 'h2', 'j1'), self.create_task(200, 3, 'h2', 'j3'), self.create_task(200, 4, 'h3', 'j4'), self.create_task(200, 4, 'h3', 'j3'), ]) hosts = ['h1', 'h2', 'h3'] jobs = set([ AuroraJobKey(self._cluster.name, self._role, self._env, 'j1'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j2'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j3'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j4') ]) self._sla.get_domain_uptime_vector(self._cluster, hosts) mock_query.assert_has_calls([call(hosts=hosts), call(job_keys=jobs)], any_order=False) def test_task_query(self): jobs = set([ AuroraJobKey(self._cluster.name, self._role, self._env, 'j1'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j2'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j3'), AuroraJobKey(self._cluster.name, self._role, self._env, 'j4') ]) query = task_query(job_keys=jobs) assert len(jobs) == len(query.jobKeys), 'Expected length:%s, Actual:%s' % ( len(jobs), len(query.jobKeys) ) assert SLA_LIVE_STATES == query.statuses, 'Expected:%s, Actual:%s' % ( SLA_LIVE_STATES, query.statuses )