def _GetGoBinaryPath(cls):
if not cls._go_binary_path:
if binary_manager.NeedsInit():
binary_manager.InitDependencyManager(None)
cls._go_binary_path = binary_manager.FetchPath(
'wpr_go', py_utils.GetHostArchName(), py_utils.GetHostOsName())
return cls._go_binary_path
def _GetGoBinaryPath(self, replay_options):
"""Gets the _go_binary_path if it already set, or downloads it."""
if USE_LOCAL_WPR in replay_options:
# Build WPR
go_folder = os.path.join(_WPR_DIR, 'src')
cur_cwd = os.getcwd()
os.chdir(go_folder)
try:
print subprocess.check_output(
['go', 'build',
os.path.join(go_folder, 'wpr.go')])
except subprocess.CalledProcessError:
exit(1)
os.chdir(cur_cwd)
return os.path.join(go_folder, 'wpr')
if not ReplayServer._go_binary_path:
downloader = self._GetDownloader()
if not downloader:
raise RuntimeError('downloader should not be None '
'while _go_binary_path is None')
ReplayServer._go_binary_path = downloader(
'wpr_go', py_utils.GetHostOsName(), py_utils.GetHostArchName())
return ReplayServer._go_binary_path
def UpdateDependency(dependency, dep_local_path, version,
os_name=None, arch_name=None):
config = os.path.join(
util.GetTelemetryDir(), 'telemetry', 'binary_dependencies.json')
if not os_name:
assert not arch_name, 'arch_name is specified but not os_name'
os_name = py_utils.GetHostOsName()
arch_name = py_utils.GetHostArchName()
else:
assert arch_name, 'os_name is specified but not arch_name'
dep_platform = '%s_%s' % (os_name, arch_name)
c = base_config.BaseConfig(config, writable=True)
try:
old_version = c.GetVersion(dependency, dep_platform)
print 'Updating from version: {}'.format(old_version)
except ValueError:
raise RuntimeError(
('binary_dependencies.json entry for %s missing or invalid; please add '
'it first! (need download_path and path_within_archive)') %
dep_platform)
if dep_local_path:
c.AddCloudStorageDependencyUpdateJob(
dependency, dep_platform, dep_local_path, version=version,
execute_job=True)
def FlashFirmware(self, hex_path, avrdude_config_path):
"""Flashes the BattOr using an avrdude config at config_path with the new
firmware at hex_path.
"""
assert not self._battor_shell, 'Cannot flash BattOr with open shell'
avrdude_binary = self._dm.FetchPath(
'avrdude_binary',
'%s_%s' % (py_utils.GetHostOsName(), py_utils.GetHostArchName()))
# Sanitize hex file path for windows. It contains <drive>:/ which avrdude
# is not capable of handling.
_, hex_path = os.path.splitdrive(hex_path)
avr_cmd = [
avrdude_binary,
'-e', # Specify to erase data on chip.
'-p', self._BATTOR_PARTNO, # Specify AVR device.
# Specify which microcontroller programmer to use.
'-c', self._BATTOR_PROGRAMMER,
'-b', self._BATTOR_BAUDRATE, # Specify the baud rate to communicate at.
'-P', self._battor_path, # Serial path to the battor.
# Command to execute with hex file and path to hex file.
'-U', 'flash:w:%s' % hex_path,
'-C', avrdude_config_path, # AVRdude config file path.
'2>&1' # All output goes to stderr for some reason.
]
try:
subprocess.check_output(avr_cmd)
except subprocess.CalledProcessError as e:
raise BattOrFlashError('BattOr flash failed with return code %s.'
% e.returncode)
self._git_hash = None
return True
def _GetGoBinaryPath(self):
"""Gets the _go_binary_path if it already set, or downloads it."""
if not ReplayServer._go_binary_path:
downloader = self._GetDownloader()
if not downloader:
raise RuntimeError('downloader should not be None '
'while _go_binary_path is None')
ReplayServer._go_binary_path = downloader(
'wpr_go', py_utils.GetHostOsName(), py_utils.GetHostArchName())
return ReplayServer._go_binary_path
def __init__(self,
target_platform,
android_device=None,
battor_path=None,
battor_map_file=None,
battor_map=None,
serial_log_bucket=None,
autoflash=True):
"""Constructor.
Args:
target_platform: Platform BattOr is attached to.
android_device: Serial number of Android device.
battor_path: Path to BattOr device.
battor_map_file: File giving map of [device serial: BattOr path]
battor_map: Map of [device serial: BattOr path]
serial_log_bucket: The cloud storage bucket to which BattOr agent serial
logs are uploaded on failure.
Attributes:
_battor_path: Path to BattOr. Typically similar to /tty/USB0.
_battor_agent_binary: Path to the BattOr agent binary used to communicate
with the BattOr.
_tracing: A bool saying if tracing has been started.
_battor_shell: A subprocess running the battor_agent_binary
_trace_results_path: Path to BattOr trace results file.
_serial_log_bucket: Cloud storage bucket to which BattOr agent serial logs
are uploaded on failure.
_serial_log_file: Temp file for the BattOr agent serial log.
"""
self._battor_path = self._GetBattOrPath(target_platform,
android_device, battor_path,
battor_map_file, battor_map)
config = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'battor_binary_dependencies.json')
self._dm = dependency_manager.DependencyManager(
[dependency_manager.BaseConfig(config)])
self._battor_agent_binary = self._dm.FetchPath(
'battor_agent_binary',
'%s_%s' % (py_utils.GetHostOsName(), py_utils.GetHostArchName()))
self._autoflash = autoflash
self._serial_log_bucket = serial_log_bucket
self._tracing = False
self._battor_shell = None
self._trace_results_path = None
self._start_tracing_time = None
self._stop_tracing_time = None
self._trace_results = None
self._serial_log_file = None
self._target_platform = target_platform
self._git_hash = None
atexit_with_log.Register(self.KillBattOrShell)
def _AddMissingURLsToArchive(self, replay_out_file):
existing_wpr = self._ExistingWpr()
if not existing_wpr:
return
missing_urls = _ExtractMissingURLsFromLog(replay_out_file)
if not missing_urls:
return
if not self.wpr_go_bin:
self.wpr_go_bin = (
binary_manager.BinaryManager([TELEMETRY_BIN_DEPS_CONFIG]).FetchPath(
'wpr_go', py_utils.GetHostArchName(), py_utils.GetHostOsName()))
subprocess.check_call([self.wpr_go_bin, 'add', existing_wpr] + missing_urls)
def __init__(self, archive_path, replay_host, http_port, https_port,
replay_options):
"""Initialize ReplayServer.
Args:
archive_path: a path to a specific WPR archive (required).
replay_host: the hostname to serve traffic.
http_port: an integer port on which to serve HTTP traffic. May be zero
to let the OS choose an available port.
https_port: an integer port on which to serve HTTPS traffic. May be zero
to let the OS choose an available port.
replay_options: an iterable of options strings to forward to replay.py.
"""
self.archive_path = archive_path
self._replay_host = replay_host
self._started_ports = {} # a dict such as {'http': 80, 'https': 443}
# A temporary path for storing stdout & stderr of the webpagereplay
# subprocess.
self._temp_log_file_path = None
go_binary_path = binary_manager.FetchPath('wpr_go',
py_utils.GetHostArchName(),
py_utils.GetHostOsName())
self._cmd_line = self._GetCommandLine(go_binary_path, http_port,
https_port, replay_options,
archive_path)
if 'record' in replay_options:
self._CheckPath('archive directory',
os.path.dirname(self.archive_path))
elif not os.path.exists(self.archive_path):
self._CheckPath('archive file', self.archive_path)
self.replay_process = None
def _GetGoBinaryPath(cls):
if not cls._go_binary_path:
cls._go_binary_path = binary_manager.FetchPath(
'wpr_go', py_utils.GetHostArchName(), py_utils.GetHostOsName())
return cls._go_binary_path
def setUp(self):
self.archive_path = binary_manager.FetchPath(
'example_domain_wpr_go_archive',
py_utils.GetHostArchName(),
py_utils.GetHostOsName())
def FetchBinaryDependencies(
platform, client_configs, fetch_reference_chrome_binary):
""" Fetch all binary dependenencies for the given |platform|.
Note: we don't fetch browser binaries by default because the size of the
binary is about 2Gb, and it requires cloud storage permission to
chrome-telemetry bucket.
Args:
platform: an instance of telemetry.core.platform
client_configs: A list of paths (string) to dependencies json files.
fetch_reference_chrome_binary: whether to fetch reference chrome binary for
the given platform.
"""
configs = [
dependency_manager.BaseConfig(TELEMETRY_PROJECT_CONFIG),
]
dep_manager = dependency_manager.DependencyManager(configs)
os_name = platform.GetOSName()
# If we're running directly on a Chrome OS device, fetch the binaries for
# linux instead, which should be compatible with CrOS. Otherwise, if we're
# running remotely on CrOS, fetch the binaries for the host platform like
# we do with android below.
if _IsChromeOSLocalMode(os_name):
os_name = 'linux'
target_platform = '%s_%s' % (os_name, platform.GetArchName())
dep_manager.PrefetchPaths(target_platform)
host_platform = None
fetch_devil_deps = False
if os_name in ('android', 'chromeos'):
host_platform = '%s_%s' % (
py_utils.GetHostOsName(), py_utils.GetHostArchName())
dep_manager.PrefetchPaths(host_platform)
if os_name == 'android':
if host_platform == 'linux_x86_64':
fetch_devil_deps = True
else:
logging.error('Devil only supports 64 bit linux as a host platform. '
'Android tests may fail.')
if fetch_reference_chrome_binary:
_FetchReferenceBrowserBinary(platform)
# For now, handle client config separately because the BUILD.gn & .isolate of
# telemetry tests in chromium src failed to include the files specified in its
# client config.
# (https://github.com/catapult-project/catapult/issues/2192)
# For now this is ok because the client configs usually don't include cloud
# storage infos.
# TODO(nednguyen): remove the logic of swallowing exception once the issue is
# fixed on Chromium side.
if client_configs:
manager = dependency_manager.DependencyManager(
list(dependency_manager.BaseConfig(c) for c in client_configs))
try:
manager.PrefetchPaths(target_platform)
if host_platform is not None:
manager.PrefetchPaths(host_platform)
except dependency_manager.NoPathFoundError as e:
logging.error('Error when trying to prefetch paths for %s: %s',
target_platform, e.message)
if fetch_devil_deps:
devil_env.config.Initialize()
devil_env.config.PrefetchPaths(arch=platform.GetArchName())
devil_env.config.PrefetchPaths()
def _GetGoBinaryPath(cls, downloader):
if not cls._go_binary_path:
cls._go_binary_path = downloader('wpr_go',
py_utils.GetHostOsName(),
py_utils.GetHostArchName())
return cls._go_binary_path
def testConsistentHostPlatformInfo(self):
self.assertEquals(platform.GetHostPlatform().GetOSName(),
py_utils.GetHostOsName())
self.assertEquals(platform.GetHostPlatform().GetArchName(),
py_utils.GetHostArchName())
def GetWPRArchiveFromConfig(test_name, config):
"""Downloads the wpr archive from given config and test name."""
return binary_manager.BinaryManager(config).FetchPath(
test_name, py_utils.GetHostOsName(), py_utils.GetHostArchName())
