예제 #1
0
    def test_get_main_container(self):
        pod = get_simple_test_pod()
        self.assertTrue(get_main_container(pod) is not None)

        pod = get_simple_test_pod()
        pod.spec.containers[0].name = 'not_the_pod_name'
        self.assertTrue(get_main_container(pod) is None)

        pod = get_simple_test_pod()
        pod.spec.containers = []
        self.assertTrue(get_main_container(pod) is None)
예제 #2
0
    def test_get_job_descriptor(self):
        pod = get_simple_test_pod()
        self.assertTrue(get_job_descriptor(pod) is not None)

        pod = get_simple_test_pod()
        pod.metadata = None
        self.assertTrue(get_job_descriptor(pod) is None)

        pod = get_simple_test_pod()
        pod.metadata.annotations = None
        self.assertTrue(get_job_descriptor(pod) is None)

        pod = get_simple_test_pod()
        del pod.metadata.annotations[JOB_DESCRIPTOR]
        self.assertTrue(get_job_descriptor(pod) is None)
예제 #3
0
    def test_get_start_time(self):
        pod = get_simple_test_pod()
        self.assertEqual(1585004197000, get_start_time(pod))

        pod = get_simple_test_pod()
        pod.status.container_statuses = []
        self.assertEqual(None, get_start_time(pod))

        pod = get_simple_test_pod()
        pod.status.container_statuses[0].state = None
        self.assertEqual(None, get_start_time(pod))

        pod = get_simple_test_pod()
        pod.status.container_statuses[0].state.running = None
        self.assertEqual(None, get_start_time(pod))
예제 #4
0
    def test_decode_job_descriptor(self):
        pod = get_simple_test_pod()
        raw_jd = pod.metadata.annotations[JOB_DESCRIPTOR]
        self.assertTrue(decode_job_descriptor(raw_jd) is not None)

        raw_jd = "not_decodable_string"
        self.assertTrue(decode_job_descriptor(raw_jd) is None)
예제 #5
0
    def test_job_attrs_from_pod_v1(self):
        pod = get_simple_test_pod(v1=True)
        # This should have no effect - we always return static
        pod.metadata.annotations[V1_ANNOTATION_KEY_CPU_BURSTING] = "true"
        w = get_workload_from_pod(pod)

        self.assertEqual(TEST_POD_JOB_ID, w.get_job_id())
        self.assertEqual(SERVICE, w.get_job_type())
        self.assertEqual(TEST_POD_OWNER_EMAIL, w.get_owner_email())
        self.assertEqual(STATIC, w.get_type())
예제 #6
0
    def test_get_workload_from_pod(self):
        pod = get_simple_test_pod()
        get_workload_from_pod(pod)

        pod = get_simple_test_pod()
        pod.metadata.annotations[KS_WORKLOAD_JSON_OPPORTUNISTIC_CPU_KEY] = "42"
        w = get_workload_from_pod(pod)
        self.assertEqual(42, w.get_opportunistic_thread_count())

        pod = get_simple_test_pod()
        pod.metadata.annotations[
            FENZO_WORKLOAD_JSON_OPPORTUNISTIC_CPU_KEY] = "43"
        w = get_workload_from_pod(pod)
        self.assertEqual(43, w.get_opportunistic_thread_count())

        pod = get_simple_test_pod()
        pod.metadata.annotations[
            FENZO_WORKLOAD_JSON_OPPORTUNISTIC_CPU_KEY] = "15"
        pod.metadata.annotations[KS_WORKLOAD_JSON_OPPORTUNISTIC_CPU_KEY] = "16"
        w = get_workload_from_pod(pod)
        self.assertEqual(16, w.get_opportunistic_thread_count())
예제 #7
0
    def test_free_cpu_on_container_die(self):
        registry = Registry()
        test_pod = get_simple_test_pod()
        get_pod_manager().set_pod(test_pod)
        workload_name = test_pod.metadata.name

        events = [
            get_container_create_event(DEFAULT_CPU_COUNT, STATIC,
                                       workload_name, workload_name),
            get_container_die_event(workload_name)
        ]
        event_count = len(events)
        event_iterable = MockEventProvider(
            events, 1)  # Force in order event processing for the test

        test_context = TestContext()
        manager = EventManager(event_iterable,
                               test_context.get_event_handlers(),
                               DEFAULT_TEST_EVENT_TIMEOUT_SECS)
        manager.set_registry(registry, {})
        manager.start_processing_events()

        wait_until(lambda: event_count == manager.get_processed_count())
        self.assertEqual(0, manager.get_queue_depth())
        self.assertEqual(DEFAULT_TOTAL_THREAD_COUNT,
                         len(test_context.get_cpu().get_empty_threads()))
        self.assertEqual(
            1,
            test_context.get_create_event_handler().get_handled_event_count())
        self.assertEqual(
            1,
            test_context.get_free_event_handler().get_handled_event_count())

        manager.stop_processing_events()

        manager.report_metrics({})
        self.assertTrue(gauge_value_equals(registry, QUEUE_DEPTH_KEY, 0))
        self.assertTrue(
            counter_value_equals(
                registry, EVENT_SUCCEEDED_KEY,
                event_count * len(test_context.get_event_handlers())))
        self.assertTrue(counter_value_equals(registry, EVENT_FAILED_KEY, 0))
        self.assertTrue(
            counter_value_equals(registry, EVENT_PROCESSED_KEY, event_count))
예제 #8
0
 def test_get_workload_from_pod(self):
     pod = get_simple_test_pod()
     get_workload_from_pod(pod)