| # Copyright (c) 2012 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 logging |
| import os |
| import pprint |
| import shutil |
| import subprocess |
| import sys |
| import time |
| from autotest_lib.client.bin import test, utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chrome |
| from autotest_lib.client.cros import constants, cros_logging |
| |
| # The name of the Chrome OS Pepper Flash binary. |
| _BINARY = 'libpepflashplayer.so' |
| # The path to the system provided (read only) Flash binary. |
| _SYSTEM_STORE = '/opt/google/chrome/pepper' |
| # The name of the file containing metainformation for the system binary. |
| _FLASH_INFO = 'pepper-flash.info' |
| # The name of the component updated manifest describing version, OS, |
| # architecture and required ppapi interfaces. |
| _MANIFEST = 'manifest.json' |
| # The tmp location Chrome downloads the bits from Omaha to. |
| _DOWNLOAD_STORE = '/home/chronos/PepperFlash' |
| # The location the CrOS component updater stores new images in. |
| _COMPONENT_STORE = '/var/lib/imageloader/PepperFlashPlayer' |
| # latest-version gets updated after the library in the store. We use it to |
| # check for completion of download. |
| _COMPONENT_STORE_LATEST = _COMPONENT_STORE + '/latest-version' |
| # The location at which the latest component updated Flash binary is mounted |
| # for execution. |
| _COMPONENT_MOUNT = '/run/imageloader/PepperFlashPlayer' |
| # Set of all possible paths at which Flash binary could be found. |
| _FLASH_PATHS = { |
| _SYSTEM_STORE, _DOWNLOAD_STORE, _COMPONENT_STORE, _COMPONENT_MOUNT} |
| |
| # Run the traditional Flash sanity check (just check that any Flash works). |
| _CU_ACTION_SANITY = 'sanity' |
| # Clean out all component update state (in preparation to next update). |
| _CU_ACTION_DELETE = 'delete-component' |
| # TODO(ihf): Implement this action to simulated component on component update. |
| _CU_ACTION_INSTALL_OLD = 'install-old-component' |
| # Download the latest available component from Omaha. |
| _CU_ACTION_DOWNLOAD = 'download-omaha-component' |
| # Using current state of DUT verify the Flash in _COMPONENT_MOUNT. |
| _CU_ACTION_VERIFY_COMPONENT = 'verify-component-flash' |
| # Using current state of DUT verify the Flash shipping with the system image. |
| _CU_ACTION_VERIFY_SYSTEM = 'verify-system-flash' |
| |
| |
| class desktopui_FlashSanityCheck(test.test): |
| """ |
| Sanity test that ensures flash instance is launched when a swf is played. |
| """ |
| version = 4 |
| |
| _messages_log_reader = None |
| _ui_log_reader = None |
| _test_url = None |
| _testServer = None |
| _time_to_wait_secs = 5 |
| _swf_runtime = 5 |
| _retries = 10 |
| _component_download_timeout_secs = 300 |
| |
| def verify_file(self, name): |
| """ |
| Does sanity checks on a file on disk. |
| """ |
| if not os.path.exists(name): |
| raise error.TestFail('Failed: File does not exist %s' % name) |
| if not os.path.isfile(name): |
| raise error.TestFail('Failed: Not a file %s' % name) |
| if os.path.getsize(name) <= 0: |
| raise error.TestFail('Failed: File is too short %s' % name) |
| if name.endswith('libpepflashplayer.so'): |
| output = subprocess.check_output(['file %s' % name], shell=True) |
| if not 'stripped' in output: |
| logging.error(output) |
| raise error.TestFail('Failed: Flash binary not stripped.') |
| if not 'dynamically linked' in output: |
| logging.error(output) |
| raise error.TestFail('Failed: Flash not dynamically linked.') |
| arch = utils.get_arch_userspace() |
| logging.info('get_arch_userspace = %s', arch) |
| if arch == 'arm' and not 'ARM' in output: |
| logging.error(output) |
| raise error.TestFail('Failed: Flash binary not for ARM.') |
| if arch == 'x86_64' and not 'x86-64' in output: |
| logging.error(output) |
| raise error.TestFail('Failed: Flash binary not for x86_64.') |
| if arch == 'i386' and not '80386' in output: |
| logging.error(output) |
| raise error.TestFail('Failed: Flash binary not for i386.') |
| logging.info('Verified file %s', name) |
| |
| def serve_swf_to_browser(self, browser): |
| """ |
| Tries to serve a sample swf to browser. |
| |
| A failure of this function does not imply a problem with Flash. |
| @param browser: The Browser object to run the test with. |
| @return: True if we managed to send swf to browser, False otherwise. |
| """ |
| # Prepare index.html/Trivial.swf to be served. |
| browser.platform.SetHTTPServerDirectories(self.bindir) |
| test_url = browser.platform.http_server.UrlOf(os.path.join(self.bindir, |
| 'index.html')) |
| tab = None |
| # BUG(485108): Work around a telemetry timing out after login. |
| try: |
| logging.info('Getting tab from telemetry...') |
| tab = browser.tabs[0] |
| except: |
| logging.warning('Unexpected exception getting tab: %s', |
| pprint.pformat(sys.exc_info()[0])) |
| if tab is None: |
| return False |
| |
| logging.info('Initialize reading system logs.') |
| self._messages_log_reader = cros_logging.LogReader() |
| self._messages_log_reader.set_start_by_current() |
| self._ui_log_reader = cros_logging.LogReader('/var/log/ui/ui.LATEST') |
| self._ui_log_reader.set_start_by_current() |
| logging.info('Done initializing system logs.') |
| |
| # Verify that the swf got pulled. |
| try: |
| tab.Navigate(test_url) |
| tab.WaitForDocumentReadyStateToBeComplete() |
| return True |
| except: |
| logging.warning('Unexpected exception waiting for document: %s', |
| pprint.pformat(sys.exc_info()[0])) |
| return False |
| |
| |
| def verify_flash_process(self, load_path=None): |
| """Verifies the Flash process runs and doesn't crash. |
| |
| @param load_path: The expected path of the Flash binary. If set |
| function and Flash was loaded from a different path, |
| function will fail the test. |
| """ |
| logging.info('Waiting for Pepper process.') |
| # Verify that we see a ppapi process and assume it is Flash. |
| ppapi = utils.wait_for_value_changed( |
| lambda: (utils.get_process_list('chrome', '--type=ppapi')), |
| old_value=[], |
| timeout_sec=self._time_to_wait_secs) |
| logging.info('ppapi process list at start: %s', ', '.join(ppapi)) |
| if not ppapi: |
| msg = 'flash/platform/pepper/pep_' |
| if not self._ui_log_reader.can_find(msg): |
| raise error.TestFail( |
| 'Failed: Flash did not start (logs) and no ppapi process ' |
| 'found.' |
| ) |
| # There is a chrome bug where the command line of the ppapi and |
| # other processes is shown as "type=zygote". Bail out if we see more |
| # than 2. Notice, we already did the waiting, so there is no need to |
| # do more of it. |
| zygote = utils.get_process_list('chrome', '--type=zygote') |
| if len(zygote) > 2: |
| logging.warning('Flash probably launched by Chrome as zygote: ' |
| '<%s>.', ', '.join(zygote)) |
| |
| # We have a ppapi process. Let it run for a little and see if it is |
| # still alive. |
| logging.info('Running Flash content for a little while.') |
| time.sleep(self._swf_runtime) |
| logging.info('Verifying the Pepper process is still around.') |
| ppapi = utils.wait_for_value_changed( |
| lambda: (utils.get_process_list('chrome', '--type=ppapi')), |
| old_value=[], |
| timeout_sec=self._time_to_wait_secs) |
| # Notice that we are not checking for equality of ppapi on purpose. |
| logging.info('PPapi process list found: <%s>', ', '.join(ppapi)) |
| |
| # Any better pattern matching? |
| msg = ' Received crash notification for ' + constants.BROWSER |
| if self._messages_log_reader.can_find(msg): |
| raise error.TestFail('Failed: Browser crashed during test.') |
| if not ppapi: |
| raise error.TestFail( |
| 'Failed: Pepper process disappeared during test.') |
| |
| # At a minimum Flash identifies itself during process start. |
| msg = 'flash/platform/pepper/pep_' |
| if not self._ui_log_reader.can_find(msg): |
| raise error.TestFail( |
| 'Failed: Saw ppapi process but no Flash output.') |
| |
| # Check that libpepflashplayer.so was loaded from the expected path. |
| if load_path: |
| # Check all current process for Flash library. |
| output = subprocess.check_output( |
| ['grep libpepflashplayer.so /proc/*/maps'], shell=True) |
| # Verify there was no other than the expected location. |
| for dont_load_path in _FLASH_PATHS - {load_path}: |
| if dont_load_path in output: |
| logging.error('Flash incorrectly loaded from %s', |
| dont_load_path) |
| logging.info(output) |
| raise error.TestFail('Failed: Flash incorrectly loaded ' |
| 'from %s' % dont_load_path) |
| logging.info('Verified Flash was indeed not loaded from %s', |
| dont_load_path) |
| # Verify at least one of the libraries came from where we expected. |
| if not load_path in output: |
| # Mystery. We saw a Flash loaded from who knows where. |
| logging.error('Flash not loaded from %s', load_path) |
| logging.info(output) |
| raise error.TestFail('Failed: Flash not loaded from %s' % |
| load_path) |
| logging.info('Saw a flash library loaded from %s.', load_path) |
| |
| |
| def action_delete_component(self): |
| """ |
| Deletes all components on the DUT. Notice _COMPONENT_MOUNT cannot be |
| deleted. It will remain until after reboot of the DUT. |
| """ |
| if os.path.exists(_COMPONENT_STORE): |
| shutil.rmtree(_COMPONENT_STORE) |
| if os.path.exists(_COMPONENT_STORE): |
| raise error.TestFail('Error: could not delete %s', |
| _COMPONENT_STORE) |
| if os.path.exists(_DOWNLOAD_STORE): |
| shutil.rmtree(_DOWNLOAD_STORE) |
| if os.path.exists(_DOWNLOAD_STORE): |
| raise error.TestFail('Error: could not delete %s', |
| _DOWNLOAD_STORE) |
| |
| def action_download_omaha_component(self): |
| """ |
| Pretend we have no system Flash binary and tell browser to |
| accelerate the component update process. |
| TODO(ihf): Is this better than pretending the system binary is old? |
| """ |
| # TODO(ihf): Find ways to test component updates on top of component |
| # updates maybe by checking hashlib.md5(open(_COMPONENT_STORE_LATEST)). |
| if os.path.exists(_COMPONENT_STORE): |
| raise error.TestFail('Error: currently unable to test component ' |
| 'update as component store not clean before ' |
| 'download.') |
| # TODO(ihf): Remove --component-updater=test-request once Finch is set |
| # up to behave more like a user in the field. |
| browser_args = ['--ppapi-flash-path=', |
| '--ppapi-flash-version=0.0.0.0', |
| '--component-updater=fast-update,test-request'] |
| logging.info(browser_args) |
| # Browser will download component, but it will require a subsequent |
| # reboot by the caller to use it. (Browser restart is not enough.) |
| with chrome.Chrome(extra_browser_args=browser_args) as cr: |
| self.serve_swf_to_browser(cr.browser) |
| # Wait for the last file to be written by component updater. |
| utils.wait_for_value_changed( |
| lambda: (os.path.exists(_COMPONENT_STORE_LATEST)), |
| False, |
| timeout_sec=self._component_download_timeout_secs) |
| if not os.path.exists(_COMPONENT_STORE): |
| raise error.TestFail('Failed: after download no component at ' |
| '%s' % _COMPONENT_STORE) |
| # This may look silly but we prefer giving the system a bit more |
| # time to write files to disk before subsequent reboot. |
| os.system('sync') |
| time.sleep(10) |
| |
| def action_install_old_component(self): |
| """ |
| Puts an old/mock manifest and Flash binary into _COMPONENT_STORE. |
| """ |
| # TODO(ihf): Implement. Problem is, mock component binaries need to be |
| # signed by Omaha. But if we had this we could test component updating |
| # a component update. |
| pass |
| |
| def action_verify_component_flash(self): |
| """ |
| Verifies that the next use of Flash is from _COMPONENT_MOUNT. |
| """ |
| # Verify there is already a binary in the component store. |
| self.verify_file(_COMPONENT_STORE_LATEST) |
| # Verify that binary was mounted during boot. |
| self.verify_file(os.path.join(_COMPONENT_MOUNT, 'libpepflashplayer.so')) |
| self.verify_file(os.path.join(_COMPONENT_MOUNT, 'manifest.json')) |
| # Pretend we have a really old Flash revision on system to force using |
| # the downloaded component. |
| browser_args = ['--ppapi-flash-version=1.0.0.0'] |
| # Verify that Flash runs from _COMPONENT_MOUNT. |
| self.run_flash_test( |
| browser_args=browser_args, load_path=_COMPONENT_MOUNT) |
| |
| def action_verify_system_flash(self): |
| """ |
| Verifies that next use of Flash is from the _SYSTEM_STORE. |
| """ |
| # Verify there is a binary in the system store. |
| self.verify_file(os.path.join(_SYSTEM_STORE, _BINARY)) |
| # Enable component updates and pretend we have a really new Flash |
| # version on the system image. |
| browser_args = ['--ppapi-flash-version=9999.0.0.0'] |
| # Verify that Flash runs from _SYSTEM_STORE. |
| self.run_flash_test(browser_args=browser_args, load_path=_SYSTEM_STORE) |
| |
| def run_flash_test(self, browser_args=None, load_path=None): |
| """ |
| Verifies that directing the browser to an swf file results in a running |
| Pepper Flash process which does not immediately crash. |
| """ |
| if not browser_args: |
| browser_args = [] |
| # This is Flash. Disable html5 by default feature. |
| browser_args += ['--disable-features=PreferHtmlOverPlugins'] |
| # As this is an end to end test with nontrivial setup we can expect a |
| # certain amount of flakes which are *unrelated* to running Flash. We |
| # try to hide these unrelated flakes by selective retry. |
| for _ in range(0, self._retries): |
| logging.info(browser_args) |
| with chrome.Chrome(extra_browser_args=browser_args) as cr: |
| if self.serve_swf_to_browser(cr.browser): |
| self.verify_flash_process(load_path) |
| return |
| raise error.TestFail( |
| 'Error: Unable to test Flash due to setup problems.') |
| |
| def run_once(self, CU_action=_CU_ACTION_SANITY): |
| """ |
| Main entry point for desktopui_FlashSanityCheck. |
| |
| Performs an action as specified by control file or |
| by the component_UpdateFlash server test. (The current need to reboot |
| after switching to/from component binary makes this test a server test.) |
| |
| @param CU_action: component updater action to verify (typically called |
| from server test). |
| """ |
| logging.info('+++++ desktopui_FlashSanityCheck +++++') |
| logging.info('Performing %s', CU_action) |
| if CU_action == _CU_ACTION_DELETE: |
| self.action_delete_component() |
| elif CU_action == _CU_ACTION_DOWNLOAD: |
| self.action_download_omaha_component() |
| elif CU_action == _CU_ACTION_INSTALL_OLD: |
| self.action_install_old_component() |
| elif CU_action == _CU_ACTION_SANITY: |
| self.run_flash_test() |
| elif CU_action == _CU_ACTION_VERIFY_COMPONENT: |
| self.action_verify_component_flash() |
| elif CU_action == _CU_ACTION_VERIFY_SYSTEM: |
| self.action_verify_system_flash() |
| else: |
| raise error.TestError('Error: unknown action %s', CU_action) |
