Title: [122384] trunk/Tools
Revision
122384
Author
[email protected]
Date
2012-07-11 16:11:14 -0700 (Wed, 11 Jul 2012)

Log Message

nrwt: clean up names in worker.py
https://bugs.webkit.org/show_bug.cgi?id=90510

Reviewed by Ojan Vafai.

This is the last patch in the series of refactoring worker.py;
all this does is change some names of methods, instance
variables, and method parameters to be clearer (it also changes
some code in manager.py and manager_worker.py to be consistent).

There are no functional changes in this patch and the existing
tests should cover everything.

* Scripts/webkitpy/layout_tests/controllers/manager.py:
(Manager.__init__):
(Manager.prepare_lists_and_print_output):
(Manager._run_tests.worker_factory):
(Manager._run_tests):
(Manager._show_results_html_file):
(Manager.handle_finished_test_list):
(_WorkerState.__init__):
* Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py:
(_Broker.post_message):
(_Broker._dispatch_message):
(AbstractWorker.__init__):
(AbstractWorker.run):
(AbstractWorker.yield_to_caller):
(AbstractWorker.post):
(_WorkerConnection.__init__):
* Scripts/webkitpy/layout_tests/controllers/manager_worker_broker_unittest.py:
(_TestWorker.__init__):
(_TestWorker.start):
(_TestWorker.handle):
(_TestWorker.stop):
(_TestsMixin):
(_TestsMixin.test_name):
* Scripts/webkitpy/layout_tests/controllers/worker.py:
(Worker.__init__):
(Worker.__del__):
(Worker.start):
(Worker.handle):
(Worker._run_test):
(Worker.stop):
(Worker._timeout):
(Worker._kill_driver):
(Worker._run_test_with_timeout):
(Worker._clean_up_after_test):
(Worker._run_test_in_another_thread.SingleTestThread.run):
(Worker._run_test_in_this_thread):
(Worker._run_single_test):

Modified Paths

Diff

Modified: trunk/Tools/ChangeLog (122383 => 122384)


--- trunk/Tools/ChangeLog	2012-07-11 23:06:56 UTC (rev 122383)
+++ trunk/Tools/ChangeLog	2012-07-11 23:11:14 UTC (rev 122384)
@@ -1,3 +1,56 @@
+2012-07-11  Dirk Pranke  <[email protected]>
+
+        nrwt: clean up names in worker.py
+        https://bugs.webkit.org/show_bug.cgi?id=90510
+
+        Reviewed by Ojan Vafai.
+
+        This is the last patch in the series of refactoring worker.py;
+        all this does is change some names of methods, instance
+        variables, and method parameters to be clearer (it also changes
+        some code in manager.py and manager_worker.py to be consistent).
+
+        There are no functional changes in this patch and the existing
+        tests should cover everything.
+
+        * Scripts/webkitpy/layout_tests/controllers/manager.py:
+        (Manager.__init__):
+        (Manager.prepare_lists_and_print_output):
+        (Manager._run_tests.worker_factory):
+        (Manager._run_tests):
+        (Manager._show_results_html_file):
+        (Manager.handle_finished_test_list):
+        (_WorkerState.__init__):
+        * Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py:
+        (_Broker.post_message):
+        (_Broker._dispatch_message):
+        (AbstractWorker.__init__):
+        (AbstractWorker.run):
+        (AbstractWorker.yield_to_caller):
+        (AbstractWorker.post):
+        (_WorkerConnection.__init__):
+        * Scripts/webkitpy/layout_tests/controllers/manager_worker_broker_unittest.py:
+        (_TestWorker.__init__):
+        (_TestWorker.start):
+        (_TestWorker.handle):
+        (_TestWorker.stop):
+        (_TestsMixin):
+        (_TestsMixin.test_name):
+        * Scripts/webkitpy/layout_tests/controllers/worker.py:
+        (Worker.__init__):
+        (Worker.__del__):
+        (Worker.start):
+        (Worker.handle):
+        (Worker._run_test):
+        (Worker.stop):
+        (Worker._timeout):
+        (Worker._kill_driver):
+        (Worker._run_test_with_timeout):
+        (Worker._clean_up_after_test):
+        (Worker._run_test_in_another_thread.SingleTestThread.run):
+        (Worker._run_test_in_this_thread):
+        (Worker._run_single_test):
+
 2012-07-11  Adam Barth  <[email protected]>
 
         The commit-queue needs some extra git config to be able to commit

Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py (122383 => 122384)


--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py	2012-07-11 23:06:56 UTC (rev 122383)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py	2012-07-11 23:11:14 UTC (rev 122384)
@@ -333,6 +333,8 @@
         # This maps worker names to the state we are tracking for each of them.
         self._worker_states = {}
 
+        self.name = 'manager'
+
     def collect_tests(self, args):
         """Find all the files to test.
 
@@ -496,7 +498,7 @@
         elif len(self._test_files) > 1:
             self._printer.print_expected("Running all %d tests." % len(self._test_files))
         else:
-            self._printer.print_expected("Running %1 test.")
+            self._printer.print_expected("Running 1 test.")
 
         # Create a sorted list of test files so the subset chunk,
         # if used, contains alphabetically consecutive tests.
@@ -769,8 +771,8 @@
         num_workers = min(num_workers, len(all_shards))
         self._log_num_workers(num_workers, len(all_shards), len(locked_shards))
 
-        def worker_factory(worker_connection, worker_number):
-            return worker.Worker(worker_connection, worker_number, self.results_directory(), self._options)
+        def worker_factory(worker_connection):
+            return worker.Worker(worker_connection, self.results_directory(), self._options)
 
         manager_connection = manager_worker_broker.get(num_workers, self, worker_factory, self._port.host)
 
@@ -781,7 +783,7 @@
         for worker_number in xrange(num_workers):
             worker_connection = manager_connection.start_worker(worker_number)
             worker_state = _WorkerState(worker_number, worker_connection)
-            self._worker_states[worker_connection.name()] = worker_state
+            self._worker_states[worker_connection.name] = worker_state
 
             time.sleep(self._port.worker_startup_delay_secs())
 
@@ -1442,8 +1444,6 @@
         results_filename = self._filesystem.join(self._results_directory, "results.html")
         self._port.show_results_html_file(results_filename)
 
-    def name(self):
-        return 'Manager'
 
     def is_done(self):
         worker_states = self._worker_states.values()
@@ -1477,7 +1477,7 @@
         self._log_worker_stack(stack)
         raise WorkerException(str(exception_value))
 
-    def handle_finished_list(self, source, list_name, num_tests, elapsed_time):
+    def handle_finished_test_list(self, source, list_name, num_tests, elapsed_time):
         self._group_stats[list_name] = (num_tests, elapsed_time)
 
         def find(name, test_lists):
@@ -1574,7 +1574,7 @@
         self.current_test_name = None
         self.next_timeout = None
         self.stats = {}
-        self.stats['name'] = worker_connection.name()
+        self.stats['name'] = worker_connection.name
         self.stats['num_tests'] = 0
         self.stats['total_time'] = 0
 

Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py (122383 => 122384)


--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py	2012-07-11 23:06:56 UTC (rev 122383)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py	2012-07-11 23:11:14 UTC (rev 122384)
@@ -171,7 +171,7 @@
         """Post a message to the appropriate topic name.
 
         Messages have a name and a tuple of optional arguments. Both must be picklable."""
-        message = _Message(client.name(), topic_name, message_name, message_args)
+        message = _Message(client.name, topic_name, message_name, message_args)
         queue = self._get_queue_for_topic(topic_name)
         queue.put(_Message.dumps(message))
 
@@ -200,7 +200,7 @@
         if not hasattr(client, 'handle_' + message.name):
             raise ValueError(
                "%s: received message '%s' it couldn't handle" %
-               (client.name(), message.name))
+               (client.name, message.name))
         optargs = message.args
         message_handler = getattr(client, 'handle_' + message.name)
         message_handler(message.src, *optargs)
@@ -268,16 +268,13 @@
         BrokerClient.__init__(self)
         self.worker = None
         self._worker_connection = worker_connection
-        self._worker_number = worker_number
-        self._name = 'worker/%d' % worker_number
+        self.worker_number = worker_number
+        self.name = 'worker/%d' % worker_number
         self._done = False
         self._canceled = False
         self._options = optparse.Values({'verbose': False})
         self.host = None
 
-    def name(self):
-        return self._name
-
     def is_done(self):
         return self._done or self._canceled
 
@@ -290,14 +287,14 @@
         exception_msg = ""
         self.host = host
 
-        self.worker.safe_init()
-        _log.debug('%s starting' % self._name)
+        self.worker.start()
+        _log.debug('%s starting' % self.name)
 
         try:
             self._worker_connection.run_message_loop()
             if not self.is_done():
                 raise AssertionError("%s: ran out of messages in worker queue."
-                                     % self._name)
+                                     % self.name)
         except KeyboardInterrupt:
             exception_msg = ", interrupted"
             self._worker_connection.raise_exception(sys.exc_info())
@@ -305,9 +302,9 @@
             exception_msg = ", exception raised"
             self._worker_connection.raise_exception(sys.exc_info())
         finally:
-            _log.debug("%s done with message loop%s" % (self._name, exception_msg))
+            _log.debug("%s done with message loop%s" % (self.name, exception_msg))
             try:
-                self.worker.cleanup()
+                self.worker.stop()
             finally:
                 # Make sure we post a done so that we can flush the log messages
                 # and clean up properly even if we raise an exception in worker.cleanup().
@@ -325,10 +322,10 @@
         method being called, so clients should not rely solely on this."""
         self._canceled = True
 
-    def yield_to_broker(self):
+    def yield_to_caller(self):
         self._worker_connection.yield_to_broker()
 
-    def post_message(self, *args):
+    def post(self, *args):
         self._worker_connection.post_message(*args)
 
 
@@ -382,17 +379,15 @@
         # actual Worker (created by worker_factory) is very confusing, but this all gets better when
         # _WorkerConnection and AbstractWorker get merged.
         self._client = AbstractWorker(self, worker_number)
-        self._worker = worker_factory(self._client, worker_number)
+        self._worker = worker_factory(self._client)
         self._client.worker = self._worker
         self._host = host
         self._log_messages = []
         self._logger = None
         self._log_handler = None
+        self.name = self._client.name
         _BrokerConnection.__init__(self, broker, self._client, ANY_WORKER_TOPIC, MANAGER_TOPIC)
 
-    def name(self):
-        return self._client.name()
-
     def cancel(self):
         raise NotImplementedError
 

Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker_unittest.py (122383 => 122384)


--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker_unittest.py	2012-07-11 23:06:56 UTC (rev 122383)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker_unittest.py	2012-07-11 23:11:14 UTC (rev 122384)
@@ -55,33 +55,27 @@
 
 
 class _TestWorker(object):
-    def __init__(self, caller, worker_number):
+    def __init__(self, caller):
         self._caller = caller
         self._thing_to_greet = 'everybody'
         self._starting_queue = starting_queue
         self._stopping_queue = stopping_queue
         self._options = optparse.Values({'verbose': False})
 
-    def name(self):
-        return WORKER_NAME
-
-    def cleanup(self):
-        pass
-
-    def handle(self, message, src, an_int, a_str):
-        assert an_int == 1
-        assert a_str == "hello, world"
-        self._caller.post_message('finished_test', 2)
-
-    def safe_init(self):
+    def start(self):
         if self._starting_queue:
             self._starting_queue.put('')
 
         if self._stopping_queue:
             self._stopping_queue.get()
 
+    def handle(self, message, src, an_int, a_str):
+        assert an_int == 1
+        assert a_str == "hello, world"
+        self._caller.post('finished_test', 2)
+
     def stop(self):
-        self._caller.post_message('done')
+        pass
 
 
 class FunctionTests(unittest.TestCase):
@@ -99,8 +93,7 @@
     """Mixin class that implements a series of tests to enforce the
     contract all implementations must follow."""
 
-    def name(self):
-        return 'TesterManager'
+    name = 'TesterManager'
 
     def is_done(self):
         return self._done
@@ -128,7 +121,7 @@
     def test_name(self):
         self.make_broker()
         worker = self._broker.start_worker(1)
-        self.assertEquals(worker.name(), WORKER_NAME)
+        self.assertEquals(worker.name, WORKER_NAME)
         worker.cancel()
         worker.join(0.1)
         self.assertFalse(worker.is_alive())

Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/worker.py (122383 => 122384)


--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/worker.py	2012-07-11 23:06:56 UTC (rev 122383)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/worker.py	2012-07-11 23:11:14 UTC (rev 122384)
@@ -41,14 +41,14 @@
 
 
 class Worker(object):
-    def __init__(self, worker_connection, worker_number, results_directory, options):
-        self._worker_connection = worker_connection
-        self._worker_number = worker_number
-        self._name = 'worker/%d' % worker_number
+    def __init__(self, caller, results_directory, options):
+        self._caller = caller
+        self._worker_number = caller.worker_number
+        self._name = caller.name
         self._results_directory = results_directory
         self._options = options
 
-        # The remaining fields are initialized in safe_init()
+        # The remaining fields are initialized in start()
         self._host = None
         self._port = None
         self._batch_size = None
@@ -59,12 +59,13 @@
         self._tests_run_filename = None
 
     def __del__(self):
-        self.cleanup()
+        self.stop()
 
-    def safe_init(self):
-        """This method is called when it is safe for the object to create state that
-        does not need to be pickled (usually this means it is called in a child process)."""
-        self._host = self._worker_connection.host
+    def start(self):
+        """This method is called when the object is starting to be used and it is safe
+        for the object to create state that does not need to be pickled (usually this means
+        it is called in a child process)."""
+        self._host = self._caller.host
         self._filesystem = self._host.filesystem
         self._port = self._host.port_factory.get(self._options.platform, self._options)
 
@@ -73,18 +74,14 @@
         tests_run_filename = self._filesystem.join(self._results_directory, "tests_run%d.txt" % self._worker_number)
         self._tests_run_file = self._filesystem.open_text_file_for_writing(tests_run_filename)
 
-    def handle(self, name, source, list_name, test_list):
+    def handle(self, name, source, test_list_name, test_inputs):
         assert name == 'test_list'
         start_time = time.time()
-        num_tests = 0
-        for test_input in test_list:
-            self._update_test_input(test_input)
+        for test_input in test_inputs:
             self._run_test(test_input)
-            num_tests += 1
-            self._worker_connection.yield_to_broker()
-
+            self._caller.yield_to_caller()
         elapsed_time = time.time() - start_time
-        self._worker_connection.post_message('finished_list', list_name, num_tests, elapsed_time)
+        self._caller.post('finished_test_list', test_list_name, len(test_inputs), elapsed_time)
 
     def _update_test_input(self, test_input):
         test_input.reference_files = self._port.reference_files(test_input.test_name)
@@ -99,25 +96,26 @@
             test_input.should_run_pixel_test = False
 
     def _run_test(self, test_input):
-        test_timeout_sec = self.timeout(test_input)
+        self._update_test_input(test_input)
+        test_timeout_sec = self._timeout(test_input)
         start = time.time()
-        self._worker_connection.post_message('started_test', test_input, test_timeout_sec)
+        self._caller.post('started_test', test_input, test_timeout_sec)
 
-        result = self.run_test_with_timeout(test_input, test_timeout_sec)
+        result = self._run_test_with_timeout(test_input, test_timeout_sec)
 
         elapsed_time = time.time() - start
-        self._worker_connection.post_message('finished_test', result, elapsed_time)
+        self._caller.post('finished_test', result, elapsed_time)
 
-        self.clean_up_after_test(test_input, result)
+        self._clean_up_after_test(test_input, result)
 
-    def cleanup(self):
+    def stop(self):
         _log.debug("%s cleaning up" % self._name)
-        self.kill_driver()
+        self._kill_driver()
         if self._tests_run_file:
             self._tests_run_file.close()
             self._tests_run_file = None
 
-    def timeout(self, test_input):
+    def _timeout(self, test_input):
         """Compute the appropriate timeout value for a test."""
         # The DumpRenderTree watchdog uses 2.5x the timeout; we want to be
         # larger than that. We also add a little more padding if we're
@@ -133,7 +131,7 @@
         thread_timeout_sec = driver_timeout_sec + thread_padding_sec
         return thread_timeout_sec
 
-    def kill_driver(self):
+    def _kill_driver(self):
         # Be careful about how and when we kill the driver; if driver.stop()
         # raises an exception, this routine may get re-entered via __del__.
         driver = self._driver
@@ -142,12 +140,12 @@
             _log.debug("%s killing driver" % self._name)
             driver.stop()
 
-    def run_test_with_timeout(self, test_input, timeout):
+    def _run_test_with_timeout(self, test_input, timeout):
         if self._options.run_singly:
             return self._run_test_in_another_thread(test_input, timeout)
         return self._run_test_in_this_thread(test_input)
 
-    def clean_up_after_test(self, test_input, result):
+    def _clean_up_after_test(self, test_input, result):
         self._batch_count += 1
         test_name = test_input.test_name
         self._tests_run_file.write(test_name + "\n")
@@ -155,7 +153,7 @@
         if result.failures:
             # Check and kill DumpRenderTree if we need to.
             if any([f.driver_needs_restart() for f in result.failures]):
-                self.kill_driver()
+                self._kill_driver()
                 # Reset the batch count since the shell just bounced.
                 self._batch_count = 0
 
@@ -169,7 +167,7 @@
             _log.debug("%s %s passed" % (self._name, test_name))
 
         if self._batch_size > 0 and self._batch_count >= self._batch_size:
-            self.kill_driver()
+            self._kill_driver()
             self._batch_count = 0
 
     def _run_test_in_another_thread(self, test_input, thread_timeout_sec):
@@ -195,7 +193,7 @@
                 self.result = None
 
             def run(self):
-                self.result = worker.run_single_test(driver, test_input)
+                self.result = worker._run_single_test(driver, test_input)
 
         thread = SingleTestThread()
         thread.start()
@@ -227,11 +225,11 @@
         Returns: a TestResult object.
         """
         if self._driver and self._driver.has_crashed():
-            self.kill_driver()
+            self._kill_driver()
         if not self._driver:
             self._driver = self._port.create_driver(self._worker_number)
-        return self.run_single_test(self._driver, test_input)
+        return self._run_single_test(self._driver, test_input)
 
-    def run_single_test(self, driver, test_input):
+    def _run_single_test(self, driver, test_input):
         return single_test_runner.run_single_test(self._port, self._options,
             test_input, driver, self._name)
_______________________________________________
webkit-changes mailing list
[email protected]
http://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to