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)