autotest/factory: Interrupt tests by factory UI.

client/bin/factory_ui

 #!/usr/bin/python
 #
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
 # DESCRIPTION :
 #
 # This UI is intended to be used by the factory autotest suite to
@@ skipping 20 matching lines @@
 import select
 import signal
 import subprocess
 import sys
 import time
 
 import common
 import factory
 import factory_state
 import factory_ui_lib as ful
+import utils
 
 from gtk import gdk
 from Xlib import X
 from Xlib.display import Display as X_Display
 
 
 # These definitions are expose these classes directly into this
 # namespace, so that the test_list that is sent from the control file
 # can have cleaner syntax.  These are done in this fashion, as opposed
 # to "from factory import <class>" to work-around Python namespace
@@ skipping 200 matching lines @@
         for name, status in test_state.get_all_tests().items():
             test = test_db.get_test_by_unique_id_str(name)
             ui_state.status_change_callback(test, status)
             if (status == factory.ACTIVE and
                 (not isinstance(test, AutomatedSubTest))):
                 ui_state.set_active_test(test_db, test)
     except Exception, e:
         factory.log('state_change_handler got exception: %s', repr(e))
     return True
 
+def kill_active_test(control_pid):
+    # Currently we kill the active test directly.
+    # If we want to use the old way - notify main control to kill it,
+    # then send USR1 to main control instead:
+    #   os.kill(control_pid, signal.SIGUSR1)
+    active_test_data = factory.get_shared_data('active_test_data')
+    if active_test_data is None:

[josephsih1, 2011/03/04 02:13:11]

As in kill_current_test_callback() in factory.py, can we add a log as --
log('SIGUSR1 ... KILLING NOTHING, no active test') -- when there is no
active_test_data?

[Hung-Te, 2011/03/04 02:21:28]

Actually we should (almost) never see this, because it's only possible in the
very very early (before any tests startup, or if the main is broken so no one is
running) of main.

Anyway I can put it back next time, thanks for the suggestion!

+        return
+    factory.log('KILLING active test %s' % repr(active_test_data))
+    try:
+        utils.nuke_pid(active_test_data[1])

[josephsih1, 2011/03/04 02:13:11]

In the original design, the subprocess killing is executed using
parallel.fork_nuke_subprocess, which invokes the checking of
parallel._check_for_subprocess_exception(). In this way, you may not need to
invoke it explicitly in suite_Factory/control. Could we maintain this way of
subprocess killing too?

[Hung-Te, 2011/03/04 02:21:28]

These are in different processes, so it would not do what we want - that will
raise exception in UI and leave nothing in main control :)

+        # To remove the dependency of utils, use kill:
+        # os.kill(active_test_data[1], signal.SIGTERM)
+    except OSError, e:
+        factory.log('Failed to kill test: ' + repr(e))
 
 def grab_shortcut_keys(kbd_shortcut_set, control_pid):
     disp = X_Display()
     root = disp.screen().root
 
     # We want to receive KeyPress events
     root.change_attributes(event_mask = X.KeyPressMask)
 
     keycode_map = {}
     for shortcut in kbd_shortcut_set:
         keysym = gdk.keyval_from_name(shortcut)
         keycode = disp.keysym_to_keycode(keysym)
         keycode_map[keycode] = shortcut
         root.grab_key(keycode, X.ControlMask, 1,
                       X.GrabModeAsync, X.GrabModeAsync)
 
     # This flushes the XGrabKey calls to the server.
     for x in range(0, root.display.pending_events()):
         root.display.next_event()
 
     def handle_xevent(src, cond, xhandle=root.display,
                       keycode_map=keycode_map,
                       control_pid=control_pid):
         for i in range(0, xhandle.pending_events()):
             xevent = xhandle.next_event()
             if xevent.type == X.KeyPress:
                 keycode = xevent.detail
                 factory.set_shared_data('activated_kbd_shortcut',
                                         keycode_map[keycode])
-                os.kill(control_pid, signal.SIGUSR1)
+                kill_active_test(control_pid)
         return True
 
     gobject.io_add_watch(root.display, gobject.IO_IN, handle_xevent)
 
 
 def main(test_list, status_file_path, control_pid):
     '''This process is launched by the autotest suite_Factory control
     process, which should be identified by the <control pid> cmdline
     argument.  When operators press keyboard shortcuts, the shortcut
     value is sent by set_shared_data() and a SIGUSR1 is sent to
@@ skipping 79 matching lines @@
 
     if len(sys.argv) != 4:
         print ('usage: %s <test list path> <status file path> <control pid>' %
                sys.argv[0])
     test_list_path, status_file_path, control_pid_str = sys.argv[1:]
     control_pid = int(control_pid_str)
 
     execfile(test_list_path)
 
     main(TEST_LIST, status_file_path, control_pid)