Move site_chrome_test, site_logging, site_log_reader, site_crash_test into cros dir.

client/cros/login.py

 # 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.
 
 import errno, logging, os, re, signal, subprocess, time
 import common
-import constants as chromeos_constants, cryptohome, ui
-from autotest_lib.client.bin import test, utils, site_log_reader
+import constants as chromeos_constants, cryptohome, log_reader, ui
+from autotest_lib.client.bin import utils
 from autotest_lib.client.common_lib import error
 
 
 _DEFAULT_TIMEOUT = 30
 
 
 class TimeoutError(error.TestError):
     """Error raised when we time out while waiting on a condition."""
     pass
 
@@ skipping 64 matching lines @@
 
     return False
 
 
 def logged_in():
     # this file is created when the session_manager emits start-user-session
     # and removed when the session_manager emits stop-user-session
     return os.path.exists(chromeos_constants.LOGGED_IN_MAGIC_FILE)
 
 
-def process_crashed(process, log_reader):
-    """Checks the log watched by |log_reader| to see if a crash was reported
+def process_crashed(process, logreader):

[kmixter1, 2010/12/16 03:12:57]

suggest renaming class and using the standard _ separation of words

[ericli, 2010/12/17 21:48:39]

With the new naming, now it makes more sense.
Done.

+    """Checks the log watched by |logreader| to see if a crash was reported
     for |process|.
 
     Returns True if so, False if not.
     """
-    return log_reader.can_find('Received crash notification for %s' % process)
+    return logreader.can_find('Received crash notification for %s' % process)
 
 
-def wait_for_condition(condition, timeout_msg, timeout, process, log_reader,
+def wait_for_condition(condition, timeout_msg, timeout, process, logreader,
                        crash_msg):
     try:
         utils.poll_for_condition(
             condition,
             TimeoutError(timeout_msg),
             timeout=timeout)
     except TimeoutError, e:
         # We could fail faster if necessary, but it'd be more complicated.
-        if process_crashed(process, log_reader):
+        if process_crashed(process, logreader):
             raise CrashError(crash_msg)
         else:
             raise e
 
 
 def attempt_login(username, password, timeout=_DEFAULT_TIMEOUT):
     """Attempt to log in.
 
     Args:
         username: str username for login
         password: str password for login
         timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: login didn't complete before timeout
         UnexpectedCondition: login manager is not running, or user is already
             logged in.
     """
     logging.info("Attempting to login using autox.py and (%s, %s)" %
                  (username, password))
 
     if not __get_session_manager_pid():
         raise UnexpectedCondition("Session manager is not running")
 
     if logged_in():
         raise UnexpectedCondition("Already logged in")
 
     # Mark /var/log/messages now; we'll run through all subsequent log messages
     # if we couldn't log in to see if the browser crashed.
-    log_reader = site_log_reader.LogReader()
-    log_reader.set_start_by_current()
+    my_log_reader = log_reader.LogReader()
+    my_log_reader.set_start_by_current()
 
     ax = ui.get_autox()
     # navigate to login screen
     ax.send_hotkey("Ctrl+Alt+L")
     # escape out of any login screen menus (e.g., the network selection menu)
     ax.send_hotkey("Escape")
     time.sleep(0.5)
     if (username):
         # focus username
         ax.send_hotkey("Alt+U")
         ax.send_text(username)
         # TODO(rginda): remove Tab after http://codereview.chromium.org/1390003
         ax.send_hotkey("Tab")
         # focus password
         ax.send_hotkey("Alt+P")
         ax.send_text(password)
         ax.send_hotkey("Return")
     else:
         ax.send_hotkey("Alt+B")  # Browse without signing-in
 
     wait_for_condition(condition=logged_in,
                        timeout_msg='Timed out waiting for login',
                        timeout=timeout,
                        process='chrome',
-                       log_reader=log_reader,
+                       logreader=my_log_reader,
                        crash_msg='Chrome crashed during login')
 
 
 def attempt_logout(timeout=_DEFAULT_TIMEOUT):
     """Attempt to log out by killing Chrome.
 
     Args:
         timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: logout didn't complete before timeout
         UnexpectedCondition: user is not logged in
     """
     if not logged_in():
         raise UnexpectedCondition('Already logged out')
 
     oldpid = __get_session_manager_pid()
 
     # Mark /var/log/messages now; we'll run through all subsequent log messages
     # if we couldn't TERM and restart the session manager.
-    log_reader = site_log_reader.LogReader()
-    log_reader.set_start_by_current()
+    my_log_reader = log_reader.LogReader()
+    my_log_reader.set_start_by_current()
 
     # Gracefully exiting the session manager causes the user's session to end.
     utils.system('pkill -TERM -o ^%s$' % chromeos_constants.SESSION_MANAGER)
 
     wait_for_condition(
         condition=lambda: __session_manager_restarted(oldpid),
         timeout_msg='Timed out waiting for logout',
         timeout=timeout,
         process='session_manager',
-        log_reader=log_reader,
+        logreader=my_log_reader,
         crash_msg='session_manager crashed while shutting down.')
 
 
 def wait_for_browser(timeout=_DEFAULT_TIMEOUT):
     """Wait until a Chrome process is running.
 
     Args:
         timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: Chrome didn't start before timeout
     """
     # Mark /var/log/messages now; we'll run through all subsequent log messages
     # if we couldn't start chrome to see if the browser crashed.
-    log_reader = site_log_reader.LogReader()
-    log_reader.set_start_by_current()
+    my_log_reader = log_reader.LogReader()
+    my_log_reader.set_start_by_current()
     wait_for_condition(
         lambda: os.system('pgrep ^%s$' % chromeos_constants.BROWSER) == 0,
         timeout_msg='Timed out waiting for Chrome to start',
         timeout=timeout,
         process='chrome',
-        log_reader=log_reader,
+        logreader=my_log_reader,
         crash_msg='Chrome crashed while starting up.')
 
 
 def wait_for_cryptohome(timeout=_DEFAULT_TIMEOUT):
     """Wait until cryptohome is mounted.
 
     Args:
         timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: cryptohome wasn't mounted before timeout
     """
     # Mark /var/log/messages now; we'll run through all subsequent log messages
     # if we couldn't get the browser up to see if the browser crashed.
-    log_reader = site_log_reader.LogReader()
-    log_reader.set_start_by_current()
+    my_log_reader = log_reader.LogReader()
+    my_log_reader.set_start_by_current()
     wait_for_condition(
         condition=lambda: cryptohome.is_mounted(),
         timeout_msg='Timed out waiting for cryptohome to be mounted',
         timeout=timeout,
         process='cryptohomed',
-        log_reader=log_reader,
+        logreader=my_log_reader,
         crash_msg='cryptohomed crashed during mount attempt')
 
 
 def wait_for_login_prompt(timeout=_DEFAULT_TIMEOUT):
     """Wait the login prompt is on screen and ready
 
     Args:
         timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: Login prompt didn't get up before timeout
     """
     # Mark /var/log/messages now; we'll run through all subsequent log messages
     # if we couldn't get the browser up to see if the browser crashed.
-    log_reader = site_log_reader.LogReader()
-    log_reader.set_start_by_current()
+    my_log_reader = log_reader.LogReader()
+    my_log_reader.set_start_by_current()
     wait_for_condition(
         condition=lambda: os.access(
             chromeos_constants.LOGIN_PROMPT_READY_MAGIC_FILE, os.F_OK),
         timeout_msg='Timed out waiting for login prompt',
         timeout=timeout,
         process='chrome',
-        log_reader=log_reader,
+        logreader=my_log_reader,
         crash_msg='Chrome crashed before the login prompt.')
 
 
 def wait_for_window_manager(timeout=_DEFAULT_TIMEOUT):
     """Wait until the window manager is running.
 
     Args:
         timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: window manager didn't start before timeout
     """
     utils.poll_for_condition(
         lambda: not os.system('pgrep ^%s$' % chromeos_constants.WINDOW_MANAGER),
         TimeoutError('Timed out waiting for window manager to start'),
         timeout=timeout)
 
 
 def wait_for_initial_chrome_window(timeout=_DEFAULT_TIMEOUT):
     """Wait until the initial Chrome window is mapped.
 
     Args:
       timeout: float number of seconds to wait
 
     Raises:
         TimeoutError: Chrome window wasn't mapped before timeout
     """
     # Mark /var/log/messages now; we'll run through all subsequent log messages
     # if we couldn't get the browser up to see if the browser crashed.
-    log_reader = site_log_reader.LogReader()
-    log_reader.set_start_by_current()
+    my_log_reader = log_reader.LogReader()
+    my_log_reader.set_start_by_current()
     wait_for_condition(
         lambda: os.access(
             chromeos_constants.CHROME_WINDOW_MAPPED_MAGIC_FILE, os.F_OK),
         'Timed out waiting for initial Chrome window',
         timeout=timeout,
         process='chrome',
-        log_reader=log_reader,
+        logreader=my_log_reader,
         crash_msg='Chrome crashed before first tab rendered.')
 
 
 def nuke_login_manager():
     nuke_process_by_name('session_manager')
     wait_for_browser()
 
 
 def nuke_process_by_name(name, with_prejudice=False):
     pid = int(utils.system_output('pgrep -o ^%s$' % name).split()[0])
@@ skipping 52 matching lines @@
     except (IOError, OSError) as error:
         logging.error(error)
 
     # Restart the UI.
     nuke_login_manager()
     utils.poll_for_condition(
         lambda: __session_manager_restarted(oldpid),
         TimeoutError('Timed out waiting for logout'),
         timeout)
     wait_for_login_prompt()