| # Copyright (c) 2011 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 glob |
| import gtk |
| import os |
| import re |
| from gtk import gdk |
| |
| from autotest_lib.client.bin import factory |
| from autotest_lib.client.bin import factory_ui_lib as ful |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.cros import gooftools |
| |
| |
| class factory_ProbeHWID(test.test): |
| version = 4 |
| SELECTION_PER_PAGE = 10 |
| HWID_AUTODETECT = None |
| |
| def probe_hwid(self): |
| """ Finds out the matching HWID by detection. |
| This function must not use any GUI resources. |
| """ |
| command = 'gooftool --probe --verbose' |
| pattern = 'Probed: ' |
| |
| (stdout, stderr, result) = gooftools.run(command, ignore_status=True) |
| |
| # Decode successfully matched results |
| hwids = [hwid.lstrip(pattern) |
| for hwid in stdout.splitlines() |
| if hwid.startswith(pattern)] |
| |
| # Decode unmatched results. |
| # Sample output: |
| # Unmatched for /usr/local/share/chromeos-hwid/components_BLAHBLAH: |
| # { 'part_id_3g': ['Actual: XXX', 'Expected: YYY']} |
| # Current System: |
| # { 'part_id_xxx': ['yyy'] }, |
| str_unmatched = 'Unmatched ' |
| str_current = 'Current System:' |
| |
| start = stderr.find(str_unmatched) |
| if start < 0: |
| start = 0 |
| end = stderr.rfind(str_current) |
| if end < 0: |
| unmatched = stderr[start:] |
| else: |
| unmatched = stderr[start:end] |
| # TODO(hungte) Sort and find best match candidate |
| unmatched = '\n'.join([line for line in unmatched.splitlines() |
| # 'gft_hwcomp' or 'probe' are debug message. |
| if not (line.startswith('gft_hwcomp:') or |
| line.startswith('probe:') or |
| (not line))]) |
| # Report the results |
| if len(hwids) < 1: |
| raise error.TestFail('\n'.join(('No HWID matched.', unmatched))) |
| if len(hwids) > 1: |
| raise error.TestError('Multiple HWIDs match current system: ' + |
| ','.join(hwids)) |
| if result != 0: |
| raise error.TestFail('HWID matched (%s) with unknown error: %s' |
| % hwids[0], result) |
| return hwids[0] |
| |
| def update_hwid(self, path_to_file): |
| """ Updates component list file to shared data LAST_PROBED_HWID_NAME, |
| and then let factory_WriteGBB to update system. factory_Finalize |
| will verify if that's set correctly. |
| This function must not use any GUI resources. |
| |
| TODO(hungte) Merge factory_WriteGBB into this test |
| |
| Args: |
| path_to_component_list: A component list file containing HWID and |
| GBB information. Use HWID_AUTODETECT for detection. |
| """ |
| if path_to_file == self.HWID_AUTODETECT: |
| path_to_file = self.probe_hwid() |
| # Set the factory state sharead data for factory_WriteGBB |
| factory.log('Set factory state shared data %s = %s' % |
| (factory.LAST_PROBED_HWID_NAME, path_to_file)) |
| factory.set_shared_data(factory.LAST_PROBED_HWID_NAME, path_to_file) |
| |
| def build_hwid_list(self): |
| files = glob.glob('/usr/local/share/chromeos-hwid/components*') |
| if not files: |
| files = glob.glob('/usr/share/chromeos-hwid/components*') |
| files.sort() |
| |
| if not files: |
| raise error.TestError('No HWID component files found on system.') |
| |
| # part_id_hwqual is required for every component list file. |
| hwids = [(eval(open(hwid_file).read())['part_id_hwqual'][0], hwid_file) |
| for hwid_file in files ] |
| |
| # Add special entries |
| special_hwids = [('<Auto Detect>', self.HWID_AUTODETECT)] |
| for hwid in hwids: |
| if hwid[0] != self.current_hwid: |
| continue |
| special_hwids += [("<Current Value: %s>" % hwid[0], hwid[1])] |
| break |
| |
| return special_hwids + hwids |
| |
| def key_release_callback(self, widget, event): |
| if self.writing: |
| return True |
| |
| # Process page navigation |
| KEY_PREV = [65361, 65362, ord('h'), ord('k')] # Left, Up |
| KEY_NEXT = [65363, 65364, ord('l'), ord('j')] # Right, Down |
| if event.keyval in KEY_PREV: |
| if self.page_index > 0: |
| self.page_index -= 1 |
| self.render_page() |
| return True |
| if event.keyval in KEY_NEXT: |
| if self.page_index < self.pages - 1: |
| self.page_index += 1 |
| self.render_page() |
| return True |
| |
| char = chr(event.keyval) if event.keyval in range(32,127) else None |
| factory.log('key_release %s(%s)' % (event.keyval, char)) |
| try: |
| select = int(char) |
| except ValueError: |
| factory.log('Need a number.') |
| return True |
| |
| select = select + self.page_index * self.SELECTION_PER_PAGE |
| if select < 0 or select >= len(self.hwid_list): |
| factory.log('Invalid selection: %d' % select) |
| return True |
| |
| data = self.hwid_list[select] |
| hwid_file = data[1] |
| if hwid_file == self.HWID_AUTODETECT: |
| self.label.set_text('Probing HWID, Please wait... (may take >30s)') |
| self.writing = True |
| gtk.main_iteration(False) # try to update screen |
| elif hwid_file: |
| factory.log('Selected: %s' % ', '.join(data).replace('\n', ' ')) |
| |
| try: |
| self.update_hwid(hwid_file) |
| except Exception, e: |
| self._fail_msg = '%s' % e |
| |
| gtk.main_quit() |
| return True |
| |
| def register_callbacks(self, window): |
| window.connect('key-release-event', self.key_release_callback) |
| window.add_events(gdk.KEY_RELEASE_MASK) |
| |
| def render_page(self): |
| msg = 'Choose a HWID:\n\n' |
| start = self.page_index * self.SELECTION_PER_PAGE |
| end = start + self.SELECTION_PER_PAGE |
| for index, data in enumerate(self.hwid_list[start:end]): |
| msg += '%s) %s\n\n' % (index, data[0]) |
| if self.pages > 1: |
| msg += '[Page %d / %d, navigate with arrow keys]' % ( |
| self.page_index + 1, self.pages) |
| self.label.set_text(msg) |
| |
| def run_once(self, autodetect=True): |
| factory.log('%s run_once' % self.__class__) |
| self._fail_msg = None |
| |
| if autodetect: |
| self.update_hwid(self.HWID_AUTODETECT) |
| else: |
| # TODO(hungte) add timeout |
| self.page_index = 0 |
| self.pages = 0 |
| self.writing = False |
| with os.popen("crossystem hwid 2>/dev/null", "r") as hwid_proc: |
| self.current_hwid = hwid_proc.read() |
| |
| self.hwid_list = self.build_hwid_list() |
| self.pages = len(self.hwid_list) / self.SELECTION_PER_PAGE |
| if len(self.hwid_list) % self.SELECTION_PER_PAGE: |
| self.pages += 1 |
| |
| self.label = ful.make_label('') |
| test_widget = gtk.EventBox() |
| test_widget.modify_bg(gtk.STATE_NORMAL, ful.BLACK) |
| test_widget.add(self.label) |
| self.render_page() |
| |
| ful.run_test_widget( |
| self.job, test_widget, |
| window_registration_callback=self.register_callbacks) |
| |
| factory.log('%s run_once finished' % repr(self.__class__)) |
| if self._fail_msg: |
| raise error.TestFail(self._fail_msg) |
