def RunCryptohomeTest(self):
"""Test Cryptohome."""
logging.info('RunCryptohomeTest: Starting chrome and logging in.')
is_arc_available = utils.is_arc_available()
arc_mode = arc_common.ARC_MODE_ENABLED if is_arc_available else None
with chrome.Chrome(arc_mode=arc_mode, num_tries=1) as cr:
# Check that the cryptohome is mounted.
# is_vault_mounted throws an exception if it fails.
logging.info('Checking mounted cryptohome.')
cryptohome.is_vault_mounted(user=cr.username, allow_fail=False)
# Navigate to about:blank.
tab = cr.browser.tabs[0]
tab.Navigate('about:blank')
# Evaluate some javascript.
logging.info('Evaluating JavaScript.')
if tab.EvaluateJavaScript('2+2') != 4:
raise TestFail('EvaluateJavaScript failed')
# ARC test.
if is_arc_available:
arc.wait_for_adb_ready()
logging.info('Android booted successfully.')
arc.wait_for_android_process('org.chromium.arc.intent_helper')
if not arc.is_package_installed('android'):
raise TestFail(
'"android" system package was not listed by '
'Package Manager.')
if is_arc_available:
utils.poll_for_condition(
lambda: not arc.is_android_container_alive(),
timeout=15,
desc='Android container still running '
'after Chrome shutdown.')
def run_once(self):
"""
Compare a list of processes, listening on TCP ports, to a
baseline. Test fails if there are mismatches.
"""
baseline_filename = _BASELINE_DEFAULT_NAME
arc_mode = None
if utils.is_arc_available():
baseline_filename = _BASELINE_ARC_NAME
arc_mode = 'enabled'
with chrome.Chrome(arc_mode=arc_mode):
cmd = (
r'lsof -n -i -sTCP:LISTEN | '
# Workaround for crosbug.com/28235 using a dynamic port #.
r'sed "s/\\(shill.*127.0.0.1\\):.*/\1:DYNAMIC LISTEN/g"')
cmd_output = utils.system_output(cmd,
ignore_status=True,
retain_output=True)
# Use the [1:] slice to discard line 0, the lsof output header.
lsof_lines = cmd_output.splitlines()[1:]
# Unlike ps, we don't have a format option so we have to parse
# lines that look like this:
# sshd 1915 root 3u IPv4 9221 0t0 TCP *:ssh (LISTEN)
# Out of that, we just want e.g. sshd *:ssh
observed_set = set([])
for line in self.remove_autotest_noise(lsof_lines):
fields = line.split()
observed_set.add('%s %s' %
(fields[_LSOF_COMMAND], fields[_LSOF_NAME]))
baseline_set = self.load_baseline(baseline_filename)
# TODO(wiley) Remove when we get per-board
# baselines (crbug.com/406013)
if webservd_helper.webservd_is_installed():
baseline_set.update(self.load_baseline('baseline.webservd'))
# If something in the observed set is not
# covered by the baseline...
new_listeners = observed_set.difference(baseline_set)
if new_listeners:
for daemon in new_listeners:
logging.error('Unexpected network listener: %s', daemon)
# Or, things in baseline are missing from the system:
missing_listeners = baseline_set.difference(observed_set)
if missing_listeners:
for daemon in missing_listeners:
logging.warning('Missing expected network listener: %s',
daemon)
# Only fail if there's unexpected listeners.
if new_listeners:
raise error.TestFail('Found unexpected network listeners')
def close(self):
"""Closes the browser.
"""
try:
if utils.is_arc_available():
arc_util.pre_processing_before_close(self)
finally:
# Calling platform.StopAllLocalServers() to tear down the telemetry
# server processes such as the one started by
# platform.SetHTTPServerDirectories(). Not calling this function
# will leak the process and may affect test results.
# (crbug.com/663387)
self._browser.platform.StopAllLocalServers()
self._browser.Close()
self._browser.platform.network_controller.Close()
def initialize(self):
self.keyboard = keyboard.Keyboard()
self.username, password = arc_util.get_test_account_info()
# Login a user session.
if utils.is_arc_available():
super(platform_LogoutPerf,
self).initialize(gaia_login=True, disable_arc_opt_in=False)
self.cr = self._chrome
else:
with tempfile.NamedTemporaryFile() as cap:
file_utils.download_file(arc_util._ARCP_URL, cap.name)
password = cap.read().rstrip()
self.cr = chrome.Chrome(gaia_login=True,
username=self.username,
password=password)
def main(args):
'''The main function.'''
if args:
print('No args for vm_sanity.py')
return os.EX_USAGE
start = datetime.datetime.now()
logging.info('Starting chrome and logging in.')
is_arc_available = utils.is_arc_available()
arc_mode = arc_common.ARC_MODE_ENABLED if is_arc_available else None
with chrome.Chrome(arc_mode=arc_mode) as cr:
# Check that the cryptohome is mounted.
# is_vault_mounted throws an exception if it fails.
logging.info('Checking mounted cryptohome.')
cryptohome.is_vault_mounted(user=cr.username, allow_fail=False)
# Navigate to about:blank.
tab = cr.browser.tabs[0]
tab.Navigate('about:blank')
# Evaluate some javascript.
logging.info('Evaluating JavaScript.')
if tab.EvaluateJavaScript('2+2') != 4:
raise TestFail('EvaluateJavaScript failed')
# ARC test.
if is_arc_available:
arc.wait_for_android_process('org.chromium.arc.intent_helper')
arc.wait_for_adb_ready()
logging.info('Android booted successfully.')
if not arc.is_package_installed('android'):
raise TestFail('"android" system package was not listed by '
'Package Manager.')
if is_arc_available:
utils.poll_for_condition(lambda: not arc.is_adb_connected(),
timeout=15,
desc='Android container still running after '
'Chrome shutdown.')
elapsed = datetime.datetime.now() - start
logging.info('Test succeeded in %s seconds.', elapsed.seconds)
def __init__(self,
logged_in=True,
extension_paths=None,
autotest_ext=False,
num_tries=3,
extra_browser_args=None,
clear_enterprise_policy=True,
expect_policy_fetch=False,
dont_override_profile=False,
disable_gaia_services=True,
disable_default_apps=True,
auto_login=True,
gaia_login=False,
username=None,
password=None,
gaia_id=None,
arc_mode=None,
arc_timeout=None,
disable_arc_opt_in=True,
disable_arc_opt_in_verification=True,
disable_arc_cpu_restriction=True,
disable_app_sync=False,
disable_play_auto_install=False,
disable_locale_sync=True,
disable_play_store_auto_update=True,
enable_assistant=False,
enterprise_arc_test=False,
init_network_controller=False,
mute_audio=False,
proxy_server=None,
login_delay=0):
"""
Constructor of telemetry wrapper.
@param logged_in: Regular user (True) or guest user (False).
@param extension_paths: path of unpacked extension to install.
@param autotest_ext: Load a component extension with privileges to
invoke chrome.autotestPrivate.
@param num_tries: Number of attempts to log in.
@param extra_browser_args: Additional argument(s) to pass to the
browser. It can be a string or a list.
@param clear_enterprise_policy: Clear enterprise policy before
logging in.
@param expect_policy_fetch: Expect that chrome can reach the device
management server and download policy.
@param dont_override_profile: Don't delete cryptohome before login.
Telemetry will output a warning with this
option.
@param disable_gaia_services: For enterprise autotests, this option may
be used to enable policy fetch.
@param disable_default_apps: For tests that exercise default apps.
@param auto_login: Does not login automatically if this is False.
Useful if you need to examine oobe.
@param gaia_login: Logs in to real gaia.
@param username: Log in using this username instead of the default.
@param password: Log in using this password instead of the default.
@param gaia_id: Log in using this gaia_id instead of the default.
@param arc_mode: How ARC instance should be started. Default is to not
start.
@param arc_timeout: Timeout to wait for ARC to boot.
@param disable_arc_opt_in: For opt in flow autotest. This option is used
to disable the arc opt in flow.
@param disable_arc_opt_in_verification:
Adds --disable-arc-opt-in-verification to browser args. This should
generally be enabled when disable_arc_opt_in is enabled. However,
for data migration tests where user's home data is already set up
with opted-in state before login, this option needs to be set to
False with disable_arc_opt_in=True to make ARC container work.
@param disable_arc_cpu_restriction:
Adds --disable-arc-cpu-restriction to browser args. This is enabled
by default and will make tests run faster and is generally
desirable unless a test is actually trying to test performance
where ARC is running in the background for some porition of the
test.
@param disable_app_sync:
Adds --arc-disable-app-sync to browser args and this disables ARC
app sync flow. By default it is enabled.
@param disable_play_auto_install:
Adds --arc-disable-play-auto-install to browser args and this
disables ARC Play Auto Install flow. By default it is enabled.
@param enable_assistant: For tests that require to enable Google
Assistant service. Default is False.
@param enterprise_arc_test: Skips opt_in causing enterprise tests to fail
@param disable_locale_sync:
Adds --arc-disable-locale-sync to browser args and this
disables locale sync between Chrome and Android container. In case
of disabling sync, Android container is started with language and
preference language list as it was set on the moment of starting
full instance. Used to prevent random app restarts caused by racy
locale change, coming from profile sync. By default locale sync is
disabled.
@param disable_play_store_auto_update:
Adds --arc-play-store-auto-update=off to browser args and this
disables Play Store, GMS Core and third-party apps auto-update.
By default auto-update is off to have stable autotest environment.
@param mute_audio: Mute audio.
@param proxy_server: To launch the chrome with --proxy-server
Adds '--proxy-server="http://$HTTP_PROXY:PORT"' to browser args. By
default proxy-server is disabled
@param login_delay: Time for idle in login screen to simulate the time
required for password typing.
"""
self._autotest_ext_path = None
# Force autotest extension if we need enable Play Store.
if (utils.is_arc_available() and
(arc_util.should_start_arc(arc_mode) or not disable_arc_opt_in)):
autotest_ext = True
if extension_paths is None:
extension_paths = []
finder_options = browser_options.BrowserFinderOptions()
if proxy_server:
finder_options.browser_options.AppendExtraBrowserArgs(
['--proxy-server="%s"' % proxy_server])
if utils.is_arc_available() and arc_util.should_start_arc(arc_mode):
if disable_arc_opt_in and disable_arc_opt_in_verification:
finder_options.browser_options.AppendExtraBrowserArgs(
['--disable-arc-opt-in-verification'])
if disable_arc_cpu_restriction:
finder_options.browser_options.AppendExtraBrowserArgs(
['--disable-arc-cpu-restriction'])
if disable_app_sync:
finder_options.browser_options.AppendExtraBrowserArgs(
['--arc-disable-app-sync'])
if disable_play_auto_install:
finder_options.browser_options.AppendExtraBrowserArgs(
['--arc-disable-play-auto-install'])
if disable_locale_sync:
finder_options.browser_options.AppendExtraBrowserArgs(
['--arc-disable-locale-sync'])
if disable_play_store_auto_update:
finder_options.browser_options.AppendExtraBrowserArgs(
['--arc-play-store-auto-update=off'])
logged_in = True
if autotest_ext:
self._autotest_ext_path = os.path.join(os.path.dirname(__file__),
'autotest_private_ext')
extension_paths.append(self._autotest_ext_path)
finder_options.browser_options.AppendExtraBrowserArgs(
['--whitelisted-extension-id=%s' % self.AUTOTEST_EXT_ID])
self._browser_type = (self.BROWSER_TYPE_LOGIN
if logged_in else self.BROWSER_TYPE_GUEST)
finder_options.browser_type = self.browser_type
if extra_browser_args:
finder_options.browser_options.AppendExtraBrowserArgs(
extra_browser_args)
# finder options must be set before parse_args(), browser options must
# be set before Create().
# TODO(crbug.com/360890) Below MUST be '2' so that it doesn't inhibit
# autotest debug logs
finder_options.verbosity = 2
finder_options.CreateParser().parse_args(args=[])
b_options = finder_options.browser_options
b_options.disable_component_extensions_with_background_pages = False
b_options.create_browser_with_oobe = True
b_options.clear_enterprise_policy = clear_enterprise_policy
b_options.dont_override_profile = dont_override_profile
b_options.disable_gaia_services = disable_gaia_services
b_options.disable_default_apps = disable_default_apps
b_options.disable_component_extensions_with_background_pages = disable_default_apps
b_options.disable_background_networking = False
b_options.expect_policy_fetch = expect_policy_fetch
b_options.auto_login = auto_login
b_options.gaia_login = gaia_login
b_options.mute_audio = mute_audio
b_options.login_delay = login_delay
if utils.is_arc_available() and not disable_arc_opt_in:
arc_util.set_browser_options_for_opt_in(b_options)
self.username = b_options.username if username is None else username
self.password = b_options.password if password is None else password
self.username = NormalizeEmail(self.username)
b_options.username = self.username
b_options.password = self.password
self.gaia_id = b_options.gaia_id if gaia_id is None else gaia_id
b_options.gaia_id = self.gaia_id
self.arc_mode = arc_mode
if logged_in:
extensions_to_load = b_options.extensions_to_load
for path in extension_paths:
extension = extension_to_load.ExtensionToLoad(
path, self.browser_type)
extensions_to_load.append(extension)
self._extensions_to_load = extensions_to_load
# Turn on collection of Chrome coredumps via creation of a magic file.
# (Without this, Chrome coredumps are trashed.)
open(constants.CHROME_CORE_MAGIC_FILE, 'w').close()
self._browser_to_create = browser_finder.FindBrowser(finder_options)
self._browser_to_create.SetUpEnvironment(b_options)
for i in range(num_tries):
try:
self._browser = self._browser_to_create.Create()
self._browser_pid = \
cros_interface.CrOSInterface().GetChromePid()
if utils.is_arc_available():
if disable_arc_opt_in:
if arc_util.should_start_arc(arc_mode):
arc_util.enable_play_store(self.autotest_ext, True)
else:
if not enterprise_arc_test:
wait_for_provisioning = \
arc_mode != arc_common.ARC_MODE_ENABLED_ASYNC
arc_util.opt_in(
browser=self.browser,
autotest_ext=self.autotest_ext,
wait_for_provisioning=wait_for_provisioning)
arc_util.post_processing_after_browser(self, arc_timeout)
if enable_assistant:
assistant_util.enable_assistant(self.autotest_ext)
break
except exceptions.LoginException as e:
logging.error('Timed out logging in, tries=%d, error=%s', i,
repr(e))
if i == num_tries - 1:
raise
if init_network_controller:
self._browser.platform.network_controller.Open()
def run_once(self):
errors = set()
# Max procs, max threads, and file max are dependent upon total memory.
# The kernel uses a formula similar to:
# MemTotal-kb / 128 = max procs
# MemTotal-kb / 64 = max threads
# MemTotal-kb / 10 = file_max
# But note that MemTotal changes at the end of initialization.
# The values used below for these settings should give sufficient head
# room for usage and kernel allocation.
ref_min = {
'file_max': 50000,
'kptr_restrict': 1,
'max_open': 1024,
'max_procs': 3000,
'max_threads': 7000,
'ngroups_max': 65536,
'nr_open': 1048576,
'pid_max': 32768,
'mmap_min_addr': 65536,
}
ref_equal = {
'leases': 1,
'panic': -1,
'protected_hardlinks': 1,
'protected_symlinks': 1,
'ptrace_scope': 1,
'randomize_va_space': 2,
'sched_rt_period_us': 1000000,
'sched_rt_runtime_us': 800000,
'sysrq': 1,
'suid-dump': 2,
'tcp_syncookies': 1,
}
refpath = {
'file_max': '/proc/sys/fs/file-max',
'leases': '/proc/sys/fs/leases-enable',
'max_open': '/proc/self/limits',
'max_procs': '/proc/self/limits',
'max_threads': '/proc/sys/kernel/threads-max',
'mmap_min_addr': '/proc/sys/vm/mmap_min_addr',
'kptr_restrict': '/proc/sys/kernel/kptr_restrict',
'ngroups_max': '/proc/sys/kernel/ngroups_max',
'nr_open': '/proc/sys/fs/nr_open',
'panic': '/proc/sys/kernel/panic',
'pid_max': '/proc/sys/kernel/pid_max',
'protected_hardlinks': '/proc/sys/fs/protected_hardlinks',
'protected_symlinks': '/proc/sys/fs/protected_symlinks',
'ptrace_scope': '/proc/sys/kernel/yama/ptrace_scope',
'randomize_va_space': '/proc/sys/kernel/randomize_va_space',
'sched_rt_period_us': '/proc/sys/kernel/sched_rt_period_us',
'sched_rt_runtime_us': '/proc/sys/kernel/sched_rt_runtime_us',
'suid-dump': '/proc/sys/fs/suid_dumpable',
'sysrq': '/proc/sys/kernel/sysrq',
'tcp_syncookies': '/proc/sys/net/ipv4/tcp_syncookies',
}
# Adjust arch-specific values.
if utils.get_arch().startswith('arm'):
ref_min['mmap_min_addr'] = 32768
if utils.get_arch().startswith('aarch64'):
ref_min['mmap_min_addr'] = 32768
# ARM-compatible limit on x86 if ARC++ is present (b/30146997)
if utils.is_arc_available():
ref_min['mmap_min_addr'] = 32768
# Adjust version-specific details.
kernel_ver = os.uname()[2]
if utils.compare_versions(kernel_ver, "3.6") < 0:
# Prior to kernel version 3.6, Yama handled link restrictions.
refpath['protected_hardlinks'] = \
'/proc/sys/kernel/yama/protected_nonaccess_hardlinks'
refpath['protected_symlinks'] = \
'/proc/sys/kernel/yama/protected_sticky_symlinks'
# Create osvalue dictionary with the same keys as refpath.
osvalue = {}
for key in refpath:
osvalue[key] = None
for key in ref_min:
osvalue[key] = self.get_limit(key, refpath[key])
if osvalue[key] < ref_min[key]:
logging.warning('%s is %d', refpath[key], osvalue[key])
logging.warning('%s should be at least %d', refpath[key],
ref_min[key])
errors.add(key)
else:
logging.info('%s is %d >= %d', refpath[key], osvalue[key],
ref_min[key])
for key in ref_equal:
osvalue[key] = self.get_limit(key, refpath[key])
if osvalue[key] != ref_equal[key]:
logging.warning('%s is set to %d', refpath[key], osvalue[key])
logging.warning('Expected %d', ref_equal[key])
errors.add(key)
else:
logging.info('%s is %d', refpath[key], osvalue[key])
# Look for anything from refpath that wasn't checked yet:
for key in osvalue:
if osvalue[key] == None:
logging.warning('%s was never checked', key)
errors.add(key)
# If self.error is not zero, there were errors.
if len(errors) > 0:
raise error.TestFail('Found incorrect values: %s' %
', '.join(errors))
def __init__(self,
logged_in=True,
extension_paths=[],
autotest_ext=False,
num_tries=3,
extra_browser_args=None,
clear_enterprise_policy=True,
dont_override_profile=False,
disable_gaia_services=True,
disable_default_apps=True,
auto_login=True,
gaia_login=False,
username=None,
password=None,
gaia_id=None,
arc_mode=None,
disable_arc_opt_in=True,
init_network_controller=False):
"""
Constructor of telemetry wrapper.
@param logged_in: Regular user (True) or guest user (False).
@param extension_paths: path of unpacked extension to install.
@param autotest_ext: Load a component extension with privileges to
invoke chrome.autotestPrivate.
@param num_tries: Number of attempts to log in.
@param extra_browser_args: Additional argument(s) to pass to the
browser. It can be a string or a list.
@param clear_enterprise_policy: Clear enterprise policy before
logging in.
@param dont_override_profile: Don't delete cryptohome before login.
Telemetry will output a warning with this
option.
@param disable_gaia_services: For enterprise autotests, this option may
be used to enable policy fetch.
@param disable_default_apps: For tests that exercise default apps.
@param auto_login: Does not login automatically if this is False.
Useful if you need to examine oobe.
@param gaia_login: Logs in to real gaia.
@param username: Log in using this username instead of the default.
@param password: Log in using this password instead of the default.
@param gaia_id: Log in using this gaia_id instead of the default.
@param arc_mode: How ARC instance should be started. Default is to not
start.
@param disable_arc_opt_in: For opt in flow autotest. This option is used
to disable the arc opt in flow.
"""
self._autotest_ext_path = None
# Force autotest extension if we need enable Play Store.
if (utils.is_arc_available() and
(arc_util.should_start_arc(arc_mode) or not disable_arc_opt_in)):
autotest_ext = True
if autotest_ext:
self._autotest_ext_path = os.path.join(os.path.dirname(__file__),
'autotest_private_ext')
extension_paths.append(self._autotest_ext_path)
finder_options = browser_options.BrowserFinderOptions()
if utils.is_arc_available() and arc_util.should_start_arc(arc_mode):
if disable_arc_opt_in:
finder_options.browser_options.AppendExtraBrowserArgs(
arc_util.get_extra_chrome_flags())
logged_in = True
self._browser_type = (self.BROWSER_TYPE_LOGIN
if logged_in else self.BROWSER_TYPE_GUEST)
finder_options.browser_type = self.browser_type
if extra_browser_args:
finder_options.browser_options.AppendExtraBrowserArgs(
extra_browser_args)
# finder options must be set before parse_args(), browser options must
# be set before Create().
# TODO(crbug.com/360890) Below MUST be '2' so that it doesn't inhibit
# autotest debug logs
finder_options.verbosity = 2
finder_options.CreateParser().parse_args(args=[])
b_options = finder_options.browser_options
b_options.disable_component_extensions_with_background_pages = False
b_options.create_browser_with_oobe = True
b_options.clear_enterprise_policy = clear_enterprise_policy
b_options.dont_override_profile = dont_override_profile
b_options.disable_gaia_services = disable_gaia_services
b_options.disable_default_apps = disable_default_apps
b_options.disable_component_extensions_with_background_pages = disable_default_apps
b_options.auto_login = auto_login
b_options.gaia_login = gaia_login
if utils.is_arc_available() and not disable_arc_opt_in:
arc_util.set_browser_options_for_opt_in(b_options)
self.username = b_options.username if username is None else username
self.password = b_options.password if password is None else password
self.username = NormalizeEmail(self.username)
b_options.username = self.username
b_options.password = self.password
self.gaia_id = b_options.gaia_id if gaia_id is None else gaia_id
b_options.gaia_id = self.gaia_id
self.arc_mode = arc_mode
if logged_in:
extensions_to_load = b_options.extensions_to_load
for path in extension_paths:
extension = extension_to_load.ExtensionToLoad(
path, self.browser_type)
extensions_to_load.append(extension)
self._extensions_to_load = extensions_to_load
# Turn on collection of Chrome coredumps via creation of a magic file.
# (Without this, Chrome coredumps are trashed.)
open(constants.CHROME_CORE_MAGIC_FILE, 'w').close()
for i in range(num_tries):
try:
browser_to_create = browser_finder.FindBrowser(finder_options)
self._browser = browser_to_create.Create(finder_options)
if utils.is_arc_available():
if disable_arc_opt_in:
if arc_util.should_start_arc(arc_mode):
arc_util.enable_play_store(self.autotest_ext)
else:
arc_util.opt_in(self.browser, self.autotest_ext)
arc_util.post_processing_after_browser(self)
break
except exceptions.LoginException as e:
logging.error('Timed out logging in, tries=%d, error=%s', i,
repr(e))
if i == num_tries - 1:
raise
if init_network_controller:
self._browser.platform.network_controller.InitializeIfNeeded()
def run_once(self):
"""Test main loop."""
t0 = time.time()
# record the PSR related info.
psr = power_utils.DisplayPanelSelfRefresh(init_time=t0)
try:
self._keyboard_backlight = power_utils.KbdBacklight()
self._set_keyboard_backlight_level()
except power_utils.KbdBacklightException as e:
logging.info("Assuming no keyboard backlight due to :: %s", str(e))
self._keyboard_backlight = None
measurements = []
if self._power_status.battery:
measurements += \
[power_status.SystemPower(self._power_status.battery_path)]
if power_utils.has_powercap_support():
measurements += power_rapl.create_powercap()
elif power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._checkpoint_logger = power_status.CheckpointLogger()
self._plog = power_status.PowerLogger(measurements,
seconds_period=20,
checkpoint_logger=self._checkpoint_logger)
self._tlog = power_status.TempLogger([],
seconds_period=20,
checkpoint_logger=self._checkpoint_logger)
self._clog = power_status.CPUStatsLogger(
seconds_period=20,
checkpoint_logger=self._checkpoint_logger)
self._meas_logs = [self._plog, self._tlog, self._clog]
for log in self._meas_logs:
log.start()
if self._log_mem_bandwidth:
self._mlog = memory_bandwidth_logger.MemoryBandwidthLogger(
raw=False, seconds_period=2)
self._mlog.start()
# record start time and end time for each task
self._task_tracker = []
ext_path = os.path.join(os.path.dirname(__file__), 'extension')
self._tmp_keyvals['username'] = self._username
arc_mode = arc_common.ARC_MODE_DISABLED
if utils.is_arc_available():
arc_mode = arc_common.ARC_MODE_ENABLED
try:
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=self._gaia_login,
username=self._username,
password=self._password,
arc_mode=arc_mode)
except exceptions.LoginException:
# already failed guest login
if not self._gaia_login:
raise
self._gaia_login = False
logging.warn("Unable to use GAIA acct %s. Using GUEST instead.\n",
self._username)
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=self._gaia_login)
if not self._gaia_login:
self._tmp_keyvals['username'] = '******'
extension = self._browser.get_extension(ext_path)
for k in params_dict:
if getattr(self, params_dict[k]) is not '':
extension.ExecuteJavaScript('var %s = %s;' %
(k, getattr(self, params_dict[k])))
# This opens a trap start page to capture tabs opened for first login.
# It will be closed when startTest is run.
extension.ExecuteJavaScript('chrome.windows.create(null, null);')
for i in range(self._loop_count):
start_time = time.time()
extension.ExecuteJavaScript('startTest();')
# the power test extension will report its status here
latch = self._testServer.add_wait_url('/status')
# this starts a thread in the server that listens to log
# information from the script
script_logging = self._testServer.add_wait_url(url='/log')
# dump any log entry that comes from the script into
# the debug log
self._testServer.add_url_handler(url='/log',\
handler_func=(lambda handler, forms, loop_counter=i:\
_extension_log_handler(handler, forms, loop_counter)))
pagetime_tracking = self._testServer.add_wait_url(url='/pagetime')
self._testServer.add_url_handler(url='/pagetime',\
handler_func=(lambda handler, forms, test_instance=self,
loop_counter=i:\
_extension_page_time_info_handler(handler, forms,
loop_counter,
test_instance)))
# setup a handler to simulate waking up the base of a detachable
# on user interaction. On scrolling, wake for 1s, on page
# navigation, wake for 10s.
self._testServer.add_url(url='/pagenav')
self._testServer.add_url(url='/scroll')
self._testServer.add_url_handler(url='/pagenav',
handler_func=(lambda handler, args, plt=self:
plt._detachable_handler.wake_base(10000)))
self._testServer.add_url_handler(url='/scroll',
handler_func=(lambda handler, args, plt=self:
plt._detachable_handler.wake_base(1000)))
# reset backlight level since powerd might've modified it
# based on ambient light
self._set_backlight_level()
self._set_lightbar_level()
if self._keyboard_backlight:
self._set_keyboard_backlight_level()
audio_helper.set_volume_levels(self._volume_level,
self._mic_gain)
low_battery = self._do_wait(self._verbose, self._loop_time,
latch)
script_logging.set()
pagetime_tracking.set()
self._log_loop_checkpoint(i, start_time, time.time())
if self._verbose:
logging.debug('loop %d completed', i)
if low_battery:
logging.info('Exiting due to low battery')
break
# done with logging from the script, so we can collect that thread
t1 = time.time()
psr.refresh()
self._tmp_keyvals['minutes_battery_life_tested'] = (t1 - t0) / 60
self._tmp_keyvals.update(psr.get_keyvals())
def cleanup(self):
self.keyboard.close()
if utils.is_arc_available():
super(platform_LogoutPerf, self).cleanup()
