server/site_tests/autoupdate_P2P/autoupdate_P2P.py - platform/external/autotest - Git at Google

 # Copyright 2018 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 re

 from autotest_lib.client.common_lib import error
 from autotest_lib.client.common_lib import utils
 from autotest_lib.client.common_lib.cros import autoupdater
 from autotest_lib.server.cros.dynamic_suite import tools
 from autotest_lib.server.cros.update_engine import update_engine_test
 from chromite.lib import retry_util

 class autoupdate_P2P(update_engine_test.UpdateEngineTest):
     """Tests a peer to peer (P2P) autoupdate."""

     version = 1

     _P2P_ATTEMPTS_FILE = '/var/lib/update_engine/prefs/p2p-num-attempts'
     _P2P_FIRST_ATTEMPT_FILE = '/var/lib/update_engine/prefs/p2p-first-attempt' \
                               '-timestamp'

     def setup(self):
         self._omaha_devserver = None


     def cleanup(self):
         logging.info('Disabling p2p_update on hosts.')
         for host in self._hosts:
             try:
                 cmd = 'update_engine_client --p2p_update=no'
                 retry_util.RetryException(error.AutoservRunError, 2, host.run,
                                           cmd)
             except Exception:
                 logging.info('Failed to disable P2P in cleanup.')
         super(autoupdate_P2P, self).cleanup()

     def _enable_p2p_update_on_hosts(self):
         """Turn on the option to enable p2p updating on both DUTs."""
         logging.info('Enabling p2p_update on hosts.')
         for host in self._hosts:
             try:
                 cmd = 'update_engine_client --p2p_update=yes'
                 retry_util.RetryException(error.AutoservRunError, 2, host.run,
                                           cmd)
             except Exception:
                 raise error.TestFail('Failed to enable p2p on %s' % host)

             if self._too_many_attempts:
                 host.run('echo 11 > %s' % self._P2P_ATTEMPTS_FILE)
             else:
                 host.run('rm %s' % self._P2P_ATTEMPTS_FILE, ignore_status=True)

             if self._deadline_expired:
                 host.run('echo 1 > %s' % self._P2P_FIRST_ATTEMPT_FILE)
             else:
                 host.run('rm %s' % self._P2P_FIRST_ATTEMPT_FILE,
                          ignore_status=True)

             host.reboot()


     def _update_dut(self, host, update_url):
         """
         Update the first DUT normally and save the update engine logs.

         @param host: the host object for the first DUT.
         @param update_url: the url to call for updating the DUT.

         """
         logging.info('Updating first DUT with a regular update.')
         try:
             updater = autoupdater.ChromiumOSUpdater(update_url, host)
             updater.update_image()
         except autoupdater.RootFSUpdateError:
             logging.exception('Failed to update the first DUT.')
             raise error.TestFail('Updating the first DUT failed. Please check '
                                  'the update_engine logs in the results dir.')
         finally:
             logging.info('Saving update engine logs to results dir.')
             host.get_file('/var/log/update_engine.log',
                           os.path.join(self.resultsdir,
                                        'update_engine.log_first_dut'))
         host.reboot()


     def _check_p2p_still_enabled(self, host):
         """
         Check that updating has not affected P2P status.

         @param host: The host that we just updated.

         """
         logging.info('Checking that p2p is still enabled after update.')
         def _is_p2p_enabled():
             p2p = host.run('update_engine_client --show_p2p_update',
                            ignore_status=True)
             if p2p.stderr is not None and 'ENABLED' in p2p.stderr:
                 return True
             else:
                 return False

         err = 'P2P was disabled after the first DUT was updated. This is not ' \
               'expected. Something probably went wrong with the update.'

         utils.poll_for_condition(_is_p2p_enabled,
                                  exception=error.TestFail(err))


     def _update_via_p2p(self, host, update_url):
         """
         Update the second DUT via P2P from the first DUT.

         We perform a non-interactive update and update_engine will check
         for other devices that have P2P enabled and download from them instead.

         @param host: The second DUT.
         @param update_url: the url to call for updating the DUT.

         """
         logging.info('Updating second host via p2p.')

         try:
             # Start a non-interactive update which is required for p2p.
             updater = autoupdater.ChromiumOSUpdater(update_url, host,
                                                     interactive=False)
             updater.update_image()
         except autoupdater.RootFSUpdateError:
             logging.exception('Failed to update the second DUT via P2P.')
             raise error.TestFail('Failed to update the second DUT. Please '
                                  'checkout update_engine logs in results dir.')
         finally:
             logging.info('Saving update engine logs to results dir.')
             host.get_file('/var/log/update_engine.log',
                           os.path.join(self.resultsdir,
                                        'update_engine.log_second_dut'))

         # Return the update_engine logs so we can check for p2p entries.
         return host.run('cat /var/log/update_engine.log').stdout


     def _check_for_p2p_entries_in_update_log(self, update_engine_log):
         """
         Ensure that the second DUT actually updated via P2P.

         We will check the update_engine log for entries that tell us that the
         update was done via P2P.

         @param update_engine_log: the update engine log for the p2p update.

         """
         logging.info('Making sure we have p2p entries in update engine log.')
         line1 = "Checking if payload is available via p2p, file_id=" \
                 "cros_update_size_(.*)_hash_(.*)"
         line2 = "Lookup complete, p2p-client returned URL " \
                 "'http://%s:(.*)/cros_update_size_(.*)_hash_(.*).cros_au'" % \
                 self._hosts[0].ip
         line3 = "Replacing URL (.*) with local URL " \
                 "http://%s:(.*)/cros_update_size_(.*)_hash_(.*).cros_au " \
                 "since p2p is enabled." % self._hosts[0].ip
         errline = "Forcibly disabling use of p2p for downloading because no " \
                   "suitable peer could be found."
         too_many_attempts_err_str = "Forcibly disabling use of p2p for " \
                                     "downloading because of previous " \
                                     "failures when using p2p."

         if re.compile(errline).search(update_engine_log) is not None:
             raise error.TestFail('P2P update was disabled because no suitable '
                                  'peer DUT was found.')
         if self._too_many_attempts or self._deadline_expired:
             ue = re.compile(too_many_attempts_err_str)
             if ue.search(update_engine_log) is None:
                 raise error.TestFail('We expected update_engine to complain '
                                      'that there were too many p2p attempts '
                                      'but it did not. Check the logs.')
             return
         for line in [line1, line2, line3]:
             ue = re.compile(line)
             if ue.search(update_engine_log) is None:
                 raise error.TestFail('We did not find p2p string "%s" in the '
                                      'update_engine log for the second host. '
                                      'Please check the update_engine logs in '
                                      'the results directory.' % line)


     def _get_build_from_job_repo_url(self, host):
         """
         Gets the build string from a hosts job_repo_url.

         @param host: Object representing host.

         """
         info = host.host_info_store.get()
         repo_url = info.attributes.get(host.job_repo_url_attribute, '')
         if not repo_url:
             raise error.TestFail('There was no job_repo_url for %s so we '
                                  'cant get a payload to use.' % host.hostname)
         return tools.get_devserver_build_from_package_url(repo_url)


     def _verify_hosts(self, job_repo_url):
         """
         Ensure that the hosts scheduled for the test are valid.

         @param job_repo_url: URL to work out the current build.

         """
         lab1 = self._hosts[0].hostname.partition('-')[0]
         lab2 = self._hosts[1].hostname.partition('-')[0]
         if lab1 != lab2:
             raise error.TestNAError('Test was given DUTs in different labs so '
                                     'P2P will not work. See crbug.com/807495.')

         logging.info('Making sure hosts can ping each other.')
         result = self._hosts[1].run('ping -c5 %s' % self._hosts[0].ip,
                                     ignore_status=True)
         logging.debug('Ping status: %s', result)
         if result.exit_status != 0:
             raise error.TestFail('Devices failed to ping each other.')
         # Get the current build. e.g samus-release/R65-10200.0.0
         if job_repo_url is None:
             logging.info('Making sure hosts have the same build.')
             _, build1 = self._get_build_from_job_repo_url(self._hosts[0])
             _, build2 = self._get_build_from_job_repo_url(self._hosts[1])
             if build1 != build2:
                 raise error.TestFail('The builds on the hosts did not match. '
                                      'Host one: %s, Host two: %s' % (build1,
                                                                      build2))


     def run_once(self, hosts, job_repo_url=None, too_many_attempts=False,
                  deadline_expired=False):
         self._hosts = hosts
         logging.info('Hosts for this test: %s', self._hosts)

         self._too_many_attempts = too_many_attempts
         self._deadline_expired = deadline_expired
         self._verify_hosts(job_repo_url)
         self._enable_p2p_update_on_hosts()

         # Get an N-to-N delta payload update url to use for the test.
         # P2P updates are very slow so we will only update with a delta payload.
         update_url = self.get_update_url_for_test(job_repo_url,
                                                   full_payload=False,
                                                   critical_update=False,
                                                   max_updates=2)

         # The first device just updates normally.
         self._update_dut(self._hosts[0], update_url)
         self._check_p2p_still_enabled(self._hosts[0])

         # Update the 2nd DUT with the delta payload via P2P from the 1st DUT.
         update_engine_log = self._update_via_p2p(self._hosts[1], update_url)
         self._check_for_p2p_entries_in_update_log(update_engine_log)
	# Copyright 2018 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 re

	from autotest_lib.client.common_lib import error
	from autotest_lib.client.common_lib import utils
	from autotest_lib.client.common_lib.cros import autoupdater
	from autotest_lib.server.cros.dynamic_suite import tools
	from autotest_lib.server.cros.update_engine import update_engine_test
	from chromite.lib import retry_util

	class autoupdate_P2P(update_engine_test.UpdateEngineTest):
	"""Tests a peer to peer (P2P) autoupdate."""

	version = 1

	_P2P_ATTEMPTS_FILE = '/var/lib/update_engine/prefs/p2p-num-attempts'
	_P2P_FIRST_ATTEMPT_FILE = '/var/lib/update_engine/prefs/p2p-first-attempt' \
	'-timestamp'

	def setup(self):
	self._omaha_devserver = None


	def cleanup(self):
	logging.info('Disabling p2p_update on hosts.')
	for host in self._hosts:
	try:
	cmd = 'update_engine_client --p2p_update=no'
	retry_util.RetryException(error.AutoservRunError, 2, host.run,
	cmd)
	except Exception:
	logging.info('Failed to disable P2P in cleanup.')
	super(autoupdate_P2P, self).cleanup()

	def _enable_p2p_update_on_hosts(self):
	"""Turn on the option to enable p2p updating on both DUTs."""
	logging.info('Enabling p2p_update on hosts.')
	for host in self._hosts:
	try:
	cmd = 'update_engine_client --p2p_update=yes'
	retry_util.RetryException(error.AutoservRunError, 2, host.run,
	cmd)
	except Exception:
	raise error.TestFail('Failed to enable p2p on %s' % host)

	if self._too_many_attempts:
	host.run('echo 11 > %s' % self._P2P_ATTEMPTS_FILE)
	else:
	host.run('rm %s' % self._P2P_ATTEMPTS_FILE, ignore_status=True)

	if self._deadline_expired:
	host.run('echo 1 > %s' % self._P2P_FIRST_ATTEMPT_FILE)
	else:
	host.run('rm %s' % self._P2P_FIRST_ATTEMPT_FILE,
	ignore_status=True)

	host.reboot()


	def _update_dut(self, host, update_url):
	"""
	Update the first DUT normally and save the update engine logs.

	@param host: the host object for the first DUT.
	@param update_url: the url to call for updating the DUT.

	"""
	logging.info('Updating first DUT with a regular update.')
	try:
	updater = autoupdater.ChromiumOSUpdater(update_url, host)
	updater.update_image()
	except autoupdater.RootFSUpdateError:
	logging.exception('Failed to update the first DUT.')
	raise error.TestFail('Updating the first DUT failed. Please check '
	'the update_engine logs in the results dir.')
	finally:
	logging.info('Saving update engine logs to results dir.')
	host.get_file('/var/log/update_engine.log',
	os.path.join(self.resultsdir,
	'update_engine.log_first_dut'))
	host.reboot()


	def _check_p2p_still_enabled(self, host):
	"""
	Check that updating has not affected P2P status.

	@param host: The host that we just updated.

	"""
	logging.info('Checking that p2p is still enabled after update.')
	def _is_p2p_enabled():
	p2p = host.run('update_engine_client --show_p2p_update',
	ignore_status=True)
	if p2p.stderr is not None and 'ENABLED' in p2p.stderr:
	return True
	else:
	return False

	err = 'P2P was disabled after the first DUT was updated. This is not ' \
	'expected. Something probably went wrong with the update.'

	utils.poll_for_condition(_is_p2p_enabled,
	exception=error.TestFail(err))


	def _update_via_p2p(self, host, update_url):
	"""
	Update the second DUT via P2P from the first DUT.

	We perform a non-interactive update and update_engine will check
	for other devices that have P2P enabled and download from them instead.

	@param host: The second DUT.
	@param update_url: the url to call for updating the DUT.

	"""
	logging.info('Updating second host via p2p.')

	try:
	# Start a non-interactive update which is required for p2p.
	updater = autoupdater.ChromiumOSUpdater(update_url, host,
	interactive=False)
	updater.update_image()
	except autoupdater.RootFSUpdateError:
	logging.exception('Failed to update the second DUT via P2P.')
	raise error.TestFail('Failed to update the second DUT. Please '
	'checkout update_engine logs in results dir.')
	finally:
	logging.info('Saving update engine logs to results dir.')
	host.get_file('/var/log/update_engine.log',
	os.path.join(self.resultsdir,
	'update_engine.log_second_dut'))

	# Return the update_engine logs so we can check for p2p entries.
	return host.run('cat /var/log/update_engine.log').stdout


	def _check_for_p2p_entries_in_update_log(self, update_engine_log):
	"""
	Ensure that the second DUT actually updated via P2P.

	We will check the update_engine log for entries that tell us that the
	update was done via P2P.

	@param update_engine_log: the update engine log for the p2p update.

	"""
	logging.info('Making sure we have p2p entries in update engine log.')
	line1 = "Checking if payload is available via p2p, file_id=" \
	"cros_update_size_(.)_hash_(.)"
	line2 = "Lookup complete, p2p-client returned URL " \
	"'http://%s:(.)/cros_update_size_(.)_hash_(.*).cros_au'" % \
	self._hosts[0].ip
	line3 = "Replacing URL (.*) with local URL " \
	"http://%s:(.)/cros_update_size_(.)_hash_(.*).cros_au " \
	"since p2p is enabled." % self._hosts[0].ip
	errline = "Forcibly disabling use of p2p for downloading because no " \
	"suitable peer could be found."
	too_many_attempts_err_str = "Forcibly disabling use of p2p for " \
	"downloading because of previous " \
	"failures when using p2p."

	if re.compile(errline).search(update_engine_log) is not None:
	raise error.TestFail('P2P update was disabled because no suitable '
	'peer DUT was found.')
	if self._too_many_attempts or self._deadline_expired:
	ue = re.compile(too_many_attempts_err_str)
	if ue.search(update_engine_log) is None:
	raise error.TestFail('We expected update_engine to complain '
	'that there were too many p2p attempts '
	'but it did not. Check the logs.')
	return
	for line in [line1, line2, line3]:
	ue = re.compile(line)
	if ue.search(update_engine_log) is None:
	raise error.TestFail('We did not find p2p string "%s" in the '
	'update_engine log for the second host. '
	'Please check the update_engine logs in '
	'the results directory.' % line)


	def _get_build_from_job_repo_url(self, host):
	"""
	Gets the build string from a hosts job_repo_url.

	@param host: Object representing host.

	"""
	info = host.host_info_store.get()
	repo_url = info.attributes.get(host.job_repo_url_attribute, '')
	if not repo_url:
	raise error.TestFail('There was no job_repo_url for %s so we '
	'cant get a payload to use.' % host.hostname)
	return tools.get_devserver_build_from_package_url(repo_url)


	def _verify_hosts(self, job_repo_url):
	"""
	Ensure that the hosts scheduled for the test are valid.

	@param job_repo_url: URL to work out the current build.

	"""
	lab1 = self._hosts[0].hostname.partition('-')[0]
	lab2 = self._hosts[1].hostname.partition('-')[0]
	if lab1 != lab2:
	raise error.TestNAError('Test was given DUTs in different labs so '
	'P2P will not work. See crbug.com/807495.')

	logging.info('Making sure hosts can ping each other.')
	result = self._hosts[1].run('ping -c5 %s' % self._hosts[0].ip,
	ignore_status=True)
	logging.debug('Ping status: %s', result)
	if result.exit_status != 0:
	raise error.TestFail('Devices failed to ping each other.')
	# Get the current build. e.g samus-release/R65-10200.0.0
	if job_repo_url is None:
	logging.info('Making sure hosts have the same build.')
	_, build1 = self._get_build_from_job_repo_url(self._hosts[0])
	_, build2 = self._get_build_from_job_repo_url(self._hosts[1])
	if build1 != build2:
	raise error.TestFail('The builds on the hosts did not match. '
	'Host one: %s, Host two: %s' % (build1,
	build2))


	def run_once(self, hosts, job_repo_url=None, too_many_attempts=False,
	deadline_expired=False):
	self._hosts = hosts
	logging.info('Hosts for this test: %s', self._hosts)

	self._too_many_attempts = too_many_attempts
	self._deadline_expired = deadline_expired
	self._verify_hosts(job_repo_url)
	self._enable_p2p_update_on_hosts()

	# Get an N-to-N delta payload update url to use for the test.
	# P2P updates are very slow so we will only update with a delta payload.
	update_url = self.get_update_url_for_test(job_repo_url,
	full_payload=False,
	critical_update=False,
	max_updates=2)

	# The first device just updates normally.
	self._update_dut(self._hosts[0], update_url)
	self._check_p2p_still_enabled(self._hosts[0])

	# Update the 2nd DUT with the delta payload via P2P from the 1st DUT.
	update_engine_log = self._update_via_p2p(self._hosts[1], update_url)
	self._check_for_p2p_entries_in_update_log(update_engine_log)