| # Copyright 2019 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. |
| """ |
| Test which updates chameleond on the Bluetooth Peer device |
| |
| This is not a test per se. This 'test' checks if the chameleond commit on the |
| Bluetooth peer device and updates it if it below the expected value. |
| |
| The expected commit and the installation bundle is downloaded from google cloud |
| storage. |
| """ |
| |
| import logging |
| import os |
| import sys |
| import time |
| import tempfile |
| |
| from datetime import datetime |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.server import test |
| from autotest_lib.client.bin import utils |
| |
| |
| # The location of the package in the cloud |
| GS_PUBLIC = 'gs://chromeos-localmirror/distfiles/bluetooth_peer_bundle/' |
| |
| # NAME of the file that stores commit info in the cloud |
| COMMIT_FILENAME = 'latest_bluetooth_commit' |
| |
| # The following needs to be kept in sync with values chameleond code |
| BUNDLE_TEMPLATE='chameleond-0.0.2-{}.tar.gz' # Name of the chamleond package |
| BUNDLE_DIR = 'chameleond-0.0.2' |
| BUNDLE_VERSION = '9999' |
| CHAMELEON_BOARD = 'fpga_tio' |
| |
| def run_cmd(peer, cmd): |
| """A wrapper around host.run().""" |
| try: |
| logging.info('executing command %s on peer',cmd) |
| result = peer.host.run(cmd) |
| logging.info('exit_status is %s', result.exit_status) |
| logging.info('stdout is %s stderr is %s', result.stdout, result.stderr) |
| output = result.stderr if result.stderr else result.stdout |
| if result.exit_status == 0: |
| return True, output |
| else: |
| return False, output |
| except error.AutoservRunError as e: |
| logging.error('Error while running cmd %s %s', cmd, e) |
| return False, None |
| |
| def is_update_needed(peer, latest_commit): |
| """ Check if update is required |
| |
| Update if the commit hash doesn't match |
| |
| @returns: True/False |
| """ |
| return not is_commit_hash_equal(peer, latest_commit) |
| |
| |
| def is_commit_hash_equal(peer, latest_commit): |
| """ Check if chameleond commit hash is the expected one""" |
| try: |
| commit = peer.get_bt_commit_hash() |
| except: |
| logging.error('Getting the commit hash failed %s', sys.exc_info()) |
| return False |
| |
| logging.debug('commit %s found on peer %s', commit, peer.host) |
| return commit == latest_commit |
| |
| |
| def perform_update(peer, latest_commit): |
| """ Update the chameleond on the peer""" |
| |
| logging.info('copy the file over to the peer') |
| try: |
| |
| cur_dir = '/tmp/' |
| bundle = BUNDLE_TEMPLATE.format(latest_commit) |
| bundle_path = os.path.join(cur_dir, bundle) |
| logging.debug('package location is %s', bundle_path) |
| |
| peer.host.send_file(bundle_path, '/tmp/') |
| except: |
| logging.error('copying the file failed %s ', sys.exc_info()) |
| logging.error(str(os.listdir(cur_dir))) |
| return False |
| |
| HOST_NOW = datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S') |
| logging.info('running make on peer') |
| cmd = ('cd %s && rm -rf %s && tar zxf %s &&' |
| 'cd %s && find -exec touch -c {} \; &&' |
| 'make install REMOTE_INSTALL=TRUE ' |
| 'HOST_NOW="%s" BUNDLE_VERSION=%s ' |
| 'CHAMELEON_BOARD=%s && rm %s%s') % (cur_dir,BUNDLE_DIR, bundle, |
| BUNDLE_DIR, HOST_NOW, |
| BUNDLE_VERSION, |
| CHAMELEON_BOARD, cur_dir, |
| bundle) |
| logging.debug(cmd) |
| status, _ = run_cmd(peer, cmd) |
| if not status: |
| logging.info('make failed') |
| return False |
| |
| logging.info('chameleond installed on peer') |
| return True |
| |
| |
| def restart_check_chameleond(peer): |
| """restart chamleond and make sure it is running.""" |
| |
| restart_cmd = 'sudo /etc/init.d/chameleond restart' |
| start_cmd = 'sudo /etc/init.d/chameleond start' |
| status_cmd = 'sudo /etc/init.d/chameleond status' |
| |
| status, _ = run_cmd(peer, restart_cmd) |
| if not status: |
| status, _ = run_cmd(peer, start_cmd) |
| if not status: |
| logging.error('restarting/starting chamleond failed') |
| # |
| #TODO: Refactor so that we wait for all peer devices all together. |
| # |
| # Wait till chameleond initialization is complete |
| time.sleep(5) |
| |
| status, output = run_cmd(peer, status_cmd) |
| expected_output = 'chameleond is running' |
| return status and expected_output in output |
| |
| |
| def update_peer(peer, latest_commit): |
| """Update the chameleond on peer devices if required""" |
| |
| if not perform_update(peer, latest_commit): |
| return False, 'Update failed' |
| |
| if not restart_check_chameleond(peer): |
| return False, 'Unable to start chameleond' |
| |
| if is_update_needed(peer, latest_commit): |
| return False, 'Commit not updated after upgrade' |
| |
| logging.info('updating chameleond succeded') |
| return True, '' |
| |
| |
| def update_peers(host, latest_commit): |
| """Update the chameleond on peer devices""" |
| |
| peer_list = host.btpeer_list[:] |
| if host.chameleon is not None: |
| peer_list.append(host.chameleon) |
| |
| if peer_list == []: |
| raise error.TestError('Bluetooth Peer not present') |
| |
| status = {} |
| for peer in peer_list: |
| if peer.get_platform() != 'RASPI': |
| logging.error('Unsupported peer %s',str(peer.host)) |
| continue |
| status[peer] = {'updated': False, |
| 'reason' : None, |
| 'update_needed' : True} |
| if not is_update_needed(peer,latest_commit): |
| status[peer]['update_needed'] = False |
| logging.info('Update not needed on peer %s', str(peer.host)) |
| continue |
| |
| status[peer]['updated'], status[peer]['reason'] = update_peer( |
| peer, latest_commit) |
| |
| logging.debug(status) |
| |
| # If none of the peer need update raise TestNA |
| if not any([v['update_needed'] for v in status.values()]): |
| raise error.TestNAError('Update not needed') |
| |
| # If any of the peers failed update, raise failure with the reason |
| if not all([v['updated'] for k,v in status.items() if v['update_needed']]): |
| for peer, v in status.items(): |
| if not v['updated']: |
| logging.error('peer %s failed %s', str(peer.host), v['reason']) |
| raise error.TestFail() |
| |
| logging.info('All eligible peers updated') |
| |
| |
| def get_latest_commit(): |
| """ Get the latest commit |
| |
| Download the file containing the latest commit and |
| parse it contents, and cleanup. |
| @returns (True,commit) in case of success (False, None) in case of failure |
| """ |
| try: |
| commit = None |
| src = GS_PUBLIC + COMMIT_FILENAME |
| |
| with tempfile.NamedTemporaryFile(suffix='bt_commit') as tmp_file: |
| tmp_filename = tmp_file.name |
| cmd = 'gsutil cp {} {}'.format(src, tmp_filename) |
| result = utils.run(cmd) |
| if result.exit_status != 0: |
| logging.debug('Downloading commit file failed with %s', result.exit_status) |
| return (False, None) |
| with open(tmp_filename) as f: |
| content = f.read() |
| logging.debug('content of the file is %s', content) |
| commit = content.strip('\n').strip() |
| |
| logging.info('latest commit is %s', commit) |
| if commit is None: |
| return (False, None) |
| else: |
| return (True, commit) |
| except Exception as e: |
| logging.error('exception %s in get_latest_commit', str(e)) |
| return (False, None) |
| |
| |
| def download_installation_files(host, commit): |
| """ Download the chameleond installation bundle""" |
| src_path = GS_PUBLIC + BUNDLE_TEMPLATE.format(commit) |
| dest_path = '/tmp/' + BUNDLE_TEMPLATE.format(commit) |
| logging.debug('chamelond bundle path is %s', src_path) |
| logging.debug('bundle path in DUT is %s', dest_path) |
| |
| cmd = 'gsutil cp {} {}'.format(src_path, dest_path) |
| try: |
| result = utils.run(cmd) |
| if result.exit_status != 0: |
| logging.debug('Downloading the chameleond bundle failed with %d', |
| result.exit_status) |
| return False |
| host.send_file(dest_path, dest_path) |
| logging.debug('file send to %s %s',host, dest_path) |
| return True |
| except Exception as e: |
| logging.error('exception %s in download_installation_files', str(e)) |
| raise error.TestFail('Failed to copy the bundle file to the DUT') |
| |
| |
| def cleanup(host, commit): |
| """ Cleanup the installation file from server.""" |
| try: |
| dest_path = '/tmp/' + BUNDLE_TEMPLATE.format(commit) |
| if os.path.exists(dest_path): |
| logging.debug('Remove file %s', dest_path) |
| os.remove(dest_path) |
| else: |
| logging.debug('File %s not found', dest_path) |
| |
| result = host.run('rm {}'.format(dest_path)) |
| if result.exit_status != 0: |
| logging.error('Unable to delete %s on dut', dest_path) |
| except Exception as e: |
| logging.error('Exception %s in cleanup', str(e)) |
| raise error.TestFail('Cleanup failed') |
| |
| |
| |
| class bluetooth_PeerUpdate(test.test): |
| """ |
| This test updates chameleond on Bluetooth peer devices |
| |
| """ |
| |
| version = 1 |
| |
| def run_once(self, host): |
| """ Update Bluetooth peer device |
| |
| @param host: the DUT, usually a chromebook |
| """ |
| try: |
| self.host = host |
| commit = None |
| (status, commit) = get_latest_commit() |
| if commit is None: |
| raise error.TestFail('Unable to get current commit') |
| if not download_installation_files(self.host, commit): |
| raise error.TestFail('Unable to download installation files ') |
| update_peers(self.host, commit) |
| finally: |
| cleanup(host, commit) |
