Remove the 'http_lock' and 'file_lock' code from webkitpy.

Tools/Scripts/webkitpy/layout_tests/controllers/manager.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 # Copyright (C) 2010 Gabor Rapcsanyi (rgabor@inf.u-szeged.hu), University of Szeged
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 63 matching lines @@
         self._port = port
         self._filesystem = port.host.filesystem
         self._options = options
         self._printer = printer
         self._expectations = None
 
         self.HTTP_SUBDIR = 'http' + port.TEST_PATH_SEPARATOR
         self.PERF_SUBDIR = 'perf'
         self.WEBSOCKET_SUBDIR = 'websocket' + port.TEST_PATH_SEPARATOR
         self.LAYOUT_TESTS_DIRECTORY = 'LayoutTests'
-
-        # disable wss server. need to install pyOpenSSL on buildbots.
-        # self._websocket_secure_server = websocket_server.PyWebSocket(
-        #        options.results_directory, use_tls=True, port=9323)
+        self._http_server_started = False
+        self._websockets_server_started = False
 
         self._results_directory = self._port.results_directory()
         self._finder = LayoutTestFinder(self._port, self._options)
         self._runner = LayoutTestRunner(self._options, self._port, self._printer, self._results_directory, self._test_is_slow)
 
     def _collect_tests(self, args):
         return self._finder.find_tests(self._options, args)
 
     def _is_http_test(self, test):
         return self.HTTP_SUBDIR in test or self._is_websocket_test(test)
@@ skipping 92 matching lines @@
 
         if not self._set_up_run(tests_to_run):
             return test_run_results.RunDetails(exit_code=-1)
 
         # Don't retry failures if an explicit list of tests was passed in.
         if self._options.retry_failures is None:
             should_retry_failures = len(paths) < len(test_names)
         else:
             should_retry_failures = self._options.retry_failures
 
+
         start_time = time.time()
         enabled_pixel_tests_in_retry = False
         try:
+            self._start_servers(tests_to_run)
+
             initial_results = self._run_tests(tests_to_run, tests_to_skip, self._options.repeat_each, self._options.iterations,
                 int(self._options.child_processes), retrying=False)
 
             tests_to_retry = self._tests_to_retry(initial_results, include_crashes=self._port.should_retry_crashes())
             if should_retry_failures and tests_to_retry and not initial_results.interrupted:
                 enabled_pixel_tests_in_retry = self._force_pixel_tests_if_needed()
 
                 _log.info('')
                 _log.info("Retrying %d unexpected failure(s) ..." % len(tests_to_retry))
                 _log.info('')
                 retry_results = self._run_tests(tests_to_retry, tests_to_skip=set(), repeat_each=1, iterations=1,
                     num_workers=1, retrying=True)
 
                 if enabled_pixel_tests_in_retry:
                     self._options.pixel_tests = False
             else:
                 retry_results = None
         finally:
+            self._stop_servers()
             self._clean_up_run()
 
         end_time = time.time()
 
         # Some crash logs can take a long time to be written out so look
         # for new logs after the test run finishes.
         _log.debug("looking for new crash logs")
         self._look_for_new_crash_logs(initial_results, start_time)
         if retry_results:
             self._look_for_new_crash_logs(retry_results, start_time)
 
         _log.debug("summarizing results")
         summarized_full_results = test_run_results.summarize_results(self._port, self._expectations, initial_results, retry_results, enabled_pixel_tests_in_retry)
         summarized_failing_results = test_run_results.summarize_results(self._port, self._expectations, initial_results, retry_results, enabled_pixel_tests_in_retry, only_include_failing=True)
         self._printer.print_results(end_time - start_time, initial_results, summarized_failing_results)
 
         exit_code = self._port.exit_code_from_summarized_results(summarized_failing_results)
         if not self._options.dry_run:
             self._write_json_files(summarized_full_results, summarized_failing_results, initial_results)
             self._upload_json_files()
 
             results_path = self._filesystem.join(self._results_directory, "results.html")
             self._copy_results_html_file(results_path)
             if self._options.show_results and (exit_code or (self._options.full_results_html and initial_results.total_failures)):
                 self._port.show_results_html_file(results_path)
 
         return test_run_results.RunDetails(exit_code, summarized_full_results, summarized_failing_results, initial_results, retry_results, enabled_pixel_tests_in_retry)
 
     def _run_tests(self, tests_to_run, tests_to_skip, repeat_each, iterations, num_workers, retrying):
-        needs_http = self._port.requires_http_server() or any(self._is_http_test(test) for test in tests_to_run)
-        needs_websockets = any(self._is_websocket_test(test) for test in tests_to_run)
 
         test_inputs = []
         for _ in xrange(iterations):
             for test in tests_to_run:
                 for _ in xrange(repeat_each):
                     test_inputs.append(self._test_input_for_file(test))
-        return self._runner.run_tests(self._expectations, test_inputs, tests_to_skip, num_workers, needs_http, needs_websockets, retrying)
+        return self._runner.run_tests(self._expectations, test_inputs, tests_to_skip, num_workers, retrying)
+
+    def _start_servers(self, tests_to_run):
+        if self._port.requires_http_server() or any(self._is_http_test(test) for test in tests_to_run):
+            self._printer.write_update('Starting HTTP server ...')
+            self._port.start_http_server(number_of_servers=(2 * self._options.max_locked_shards))
+            self._http_server_started = True
+
+        if any(self._is_websocket_test(test) for test in tests_to_run):
+            self._printer.write_update('Starting WebSocket server ...')
+            self._port.start_websocket_server()
+            self._websockets_server_started = True
+
+    def _stop_servers(self):
+        if self._http_server_started:
+            self._printer.write_update('Stopping HTTP server ...')
+            self._http_server_started = False
+            self._port.stop_http_server()
+        if self._websockets_server_started:
+            self._printer.write_update('Stopping WebSocket server ...')
+            self._websockets_server_started = False
+            self._port.stop_websocket_server()
 
     def _clean_up_run(self):
         _log.debug("Flushing stdout")
         sys.stdout.flush()
         _log.debug("Flushing stderr")
         sys.stderr.flush()
         _log.debug("Stopping helper")
         self._port.stop_helper()
         _log.debug("Cleaning up port")
         self._port.clean_up_test_run()
@@ skipping 121 matching lines @@
             return int(worker_name.split('/')[1]) if worker_name else -1
 
         stats = {}
         for result in initial_results.results_by_name.values():
             if result.type != test_expectations.SKIP:
                 stats[result.test_name] = {'results': (_worker_number(result.worker_name), result.test_number, result.pid, int(result.test_run_time * 1000), int(result.total_run_time * 1000))}
         stats_trie = {}
         for name, value in stats.iteritems():
             json_results_generator.add_path_to_trie(name, value, stats_trie)
         return stats_trie