def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
(base, arch) = port_name.rsplit('-', 1)
assert base == 'linux'
assert arch in self.SUPPORTED_VERSIONS
assert port_name in ('linux', 'linux-x86', 'linux-x86_64')
self._version = 'lucid' # We only support lucid right now.
self._architecture = arch
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = 'x86_64'
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
self._original_home = None
self._original_display = None
self._xvfb_process = None
self._xvfb_stdout = None
self._xvfb_stderr = None
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
# FIXME: Rename 32-bit port name from linux-x86 to linux-linux32 to avoid confusion.
assert port_name.startswith('linux-')
port_name_suffix = port_name.replace('linux-', '', 1)
if port_name_suffix == "x86":
self._version = "linux32"
self._architecture = "x86"
else:
self._version = port_name_suffix
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
(base, arch) = port_name.rsplit("-", 1)
assert base == "linux"
assert arch in self.SUPPORTED_VERSIONS
assert port_name in ("linux", "linux-x86", "linux-x86_64")
self._version = "lucid" # We only support lucid right now.
self._architecture = arch
if not self.get_option("disable_breakpad"):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
# FIXME: Rename 32-bit port name from linux-x86 to linux-linux32 to avoid confusion.
assert port_name.startswith('linux-')
port_name_suffix = port_name.replace('linux-', '', 1)
if port_name_suffix == "x86":
self._version = "linux32"
self._architecture = "x86"
else:
self._version = port_name_suffix
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('x86', 'x86_64')
FALLBACK_PATHS = {
'x86_64': ['linux'] + win.WinPort.latest_platform_fallback_path()
}
FALLBACK_PATHS['x86'] = ['linux-x86'] + FALLBACK_PATHS['x86_64']
DEFAULT_BUILD_DIRECTORIES = ('out', )
BUILD_REQUIREMENTS_URL = 'https://code.google.com/p/chromium/wiki/LinuxBuildInstructions'
@classmethod
def _determine_driver_path_statically(cls, host, options):
config_object = config.Config(host.executive, host.filesystem)
build_directory = getattr(options, 'build_directory', None)
finder = WebKitFinder(host.filesystem)
webkit_base = finder.webkit_base()
chromium_base = finder.chromium_base()
driver_name = getattr(options, 'driver_name', None)
if driver_name is None:
driver_name = cls.CONTENT_SHELL_NAME
if hasattr(options, 'configuration') and options.configuration:
configuration = options.configuration
else:
configuration = config_object.default_configuration()
return cls._static_build_path(host.filesystem, build_directory,
chromium_base, configuration,
[driver_name])
@staticmethod
def _determine_architecture(filesystem, executive, driver_path):
file_output = ''
if filesystem.isfile(driver_path):
# The --dereference flag tells file to follow symlinks
file_output = executive.run_command(
['file', '--brief', '--dereference', driver_path],
return_stderr=True)
if re.match(r'ELF 32-bit LSB\s+executable', file_output):
return 'x86'
if re.match(r'ELF 64-bit LSB\s+executable', file_output):
return 'x86_64'
if file_output:
_log.warning(
'Could not determine architecture from "file" output: %s' %
file_output)
# We don't know what the architecture is; default to 'x86' because
# maybe we're rebaselining and the binary doesn't actually exist,
# or something else weird is going on. It's okay to do this because
# if we actually try to use the binary, check_build() should fail.
return 'x86_64'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
return port_name + '-' + cls._determine_architecture(
host.filesystem, host.executive,
cls._determine_driver_path_statically(host, options))
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
(base, arch) = port_name.rsplit('-', 1)
assert base == 'linux'
assert arch in self.SUPPORTED_VERSIONS
assert port_name in ('linux', 'linux-x86', 'linux-x86_64')
self._version = 'lucid' # We only support lucid right now.
self._architecture = arch
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def default_baseline_search_path(self):
port_names = self.FALLBACK_PATHS[self._architecture]
return map(self._webkit_baseline_path, port_names)
def _modules_to_search_for_symbols(self):
return [self._build_path('libffmpegsumo.so')]
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(
' http://code.google.com/p/chromium/wiki/LinuxBuildInstructions'
)
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(
crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
#
# PROTECTED METHODS
#
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(),
"apache2 config file") and result
if not result:
_log.error(
' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"'
)
_log.error('')
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
def _path_to_driver(self, configuration=None):
binary_name = self.driver_name()
return self._build_path_with_configuration(configuration, binary_name)
def _path_to_helper(self):
return None
class LinuxPort(base.Port):
port_name = "linux"
SUPPORTED_VERSIONS = ("x86", "x86_64")
FALLBACK_PATHS = {"x86_64": ["linux"] + win.WinPort.latest_platform_fallback_path()}
FALLBACK_PATHS["x86"] = ["linux-x86"] + FALLBACK_PATHS["x86_64"]
DEFAULT_BUILD_DIRECTORIES = ("out",)
BUILD_REQUIREMENTS_URL = "https://code.google.com/p/chromium/wiki/LinuxBuildInstructions"
@classmethod
def _determine_driver_path_statically(cls, host, options):
config_object = config.Config(host.executive, host.filesystem)
build_directory = getattr(options, "build_directory", None)
finder = WebKitFinder(host.filesystem)
webkit_base = finder.webkit_base()
chromium_base = finder.chromium_base()
driver_name = getattr(options, "driver_name", None)
if driver_name is None:
driver_name = cls.CONTENT_SHELL_NAME
if hasattr(options, "configuration") and options.configuration:
configuration = options.configuration
else:
configuration = config_object.default_configuration()
return cls._static_build_path(host.filesystem, build_directory, chromium_base, configuration, [driver_name])
@staticmethod
def _determine_architecture(filesystem, executive, driver_path):
file_output = ""
if filesystem.isfile(driver_path):
# The --dereference flag tells file to follow symlinks
file_output = executive.run_command(["file", "--brief", "--dereference", driver_path], return_stderr=True)
if re.match(r"ELF 32-bit LSB\s+(executable|shared object)", file_output):
return "x86"
if re.match(r"ELF 64-bit LSB\s+(executable|shared object)", file_output):
return "x86_64"
if file_output:
_log.warning('Could not determine architecture from "file" output: %s' % file_output)
# We don't know what the architecture is; default to 'x86_64' because
# maybe we're rebaselining and the binary doesn't actually exist,
# or something else weird is going on. It's okay to do this because
# if we actually try to use the binary, check_build() should fail.
return "x86_64"
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith("linux"):
return (
port_name
+ "-"
+ cls._determine_architecture(
host.filesystem, host.executive, cls._determine_driver_path_statically(host, options)
)
)
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
(base, arch) = port_name.rsplit("-", 1)
assert base == "linux"
assert arch in self.SUPPORTED_VERSIONS
assert port_name in ("linux", "linux-x86", "linux-x86_64")
self._version = "lucid" # We only support lucid right now.
self._architecture = arch
if not self.get_option("disable_breakpad"):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def additional_drt_flag(self):
flags = super(LinuxPort, self).additional_drt_flag()
if not self.get_option("disable_breakpad"):
flags += ["--enable-crash-reporter", "--crash-dumps-dir=%s" % self._dump_reader.crash_dumps_directory()]
return flags
def default_baseline_search_path(self):
port_names = self.FALLBACK_PATHS[self._architecture]
return map(self._webkit_baseline_path, port_names)
def _modules_to_search_for_symbols(self):
return [self._build_path("libffmpegsumo.so")]
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error("For complete Linux build requirements, please see:")
_log.error("")
_log.error(" http://code.google.com/p/chromium/wiki/LinuxBuildInstructions")
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option("disable_breakpad"):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option("disable_breakpad"):
self._dump_reader.clobber_old_results()
def operating_system(self):
return "linux"
#
# PROTECTED METHODS
#
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(), "apache2 config file") and result
if not result:
_log.error(' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"')
_log.error("")
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
def _path_to_driver(self, configuration=None):
binary_name = self.driver_name()
return self._build_path_with_configuration(configuration, binary_name)
def _path_to_helper(self):
return None
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('precise', 'trusty')
FALLBACK_PATHS = {}
FALLBACK_PATHS['trusty'] = ['linux'] + win.WinPort.latest_platform_fallback_path()
FALLBACK_PATHS['precise'] = ['linux-precise'] + FALLBACK_PATHS['trusty']
DEFAULT_BUILD_DIRECTORIES = ('out',)
BUILD_REQUIREMENTS_URL = 'https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
assert host.platform.is_linux()
version = host.platform.os_version
return port_name + '-' + version
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def additional_driver_flag(self):
flags = super(LinuxPort, self).additional_driver_flag()
if not self.get_option('disable_breakpad'):
flags += ['--enable-crash-reporter', '--crash-dumps-dir=%s' % self._dump_reader.crash_dumps_directory()]
return flags
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(' https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md')
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
#
# PROTECTED METHODS
#
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(), "apache2 config file") and result
if not result:
_log.error(' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"')
_log.error('')
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def _path_to_driver(self, configuration=None):
binary_name = self.driver_name()
return self._build_path_with_configuration(configuration, binary_name)
def _path_to_helper(self):
return None
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('precise', 'trusty')
FALLBACK_PATHS = {}
FALLBACK_PATHS['trusty'] = [
'linux'
] + win.WinPort.latest_platform_fallback_path()
FALLBACK_PATHS['precise'] = ['linux-precise'] + FALLBACK_PATHS['trusty']
DEFAULT_BUILD_DIRECTORIES = ('out', )
BUILD_REQUIREMENTS_URL = 'https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
assert host.platform.is_linux()
version = host.platform.os_version
return port_name + '-' + version
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def additional_driver_flag(self):
flags = super(LinuxPort, self).additional_driver_flag()
if not self.get_option('disable_breakpad'):
flags += [
'--enable-crash-reporter',
'--crash-dumps-dir=%s' %
self._dump_reader.crash_dumps_directory()
]
return flags
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(
' https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md'
)
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(
crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
#
# PROTECTED METHODS
#
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(),
"apache2 config file") and result
if not result:
_log.error(
' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"'
)
_log.error('')
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def _path_to_driver(self, target=None):
binary_name = self.driver_name()
return self._build_path_with_target(target, binary_name)
def _path_to_helper(self):
return None
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('x86', 'x86_64')
FALLBACK_PATHS = { 'x86_64': [ 'linux' ] + win.WinPort.latest_platform_fallback_path() }
FALLBACK_PATHS['x86'] = ['linux-x86'] + FALLBACK_PATHS['x86_64']
DEFAULT_BUILD_DIRECTORIES = ('out',)
@classmethod
def _determine_driver_path_statically(cls, host, options):
config_object = config.Config(host.executive, host.filesystem)
build_directory = getattr(options, 'build_directory', None)
finder = WebKitFinder(host.filesystem)
webkit_base = finder.webkit_base()
chromium_base = finder.chromium_base()
driver_name = getattr(options, 'driver_name', None)
if driver_name is None:
driver_name = cls.CONTENT_SHELL_NAME
if hasattr(options, 'configuration') and options.configuration:
configuration = options.configuration
else:
configuration = config_object.default_configuration()
return cls._static_build_path(host.filesystem, build_directory, chromium_base, configuration, [driver_name])
@staticmethod
def _determine_architecture(filesystem, executive, driver_path):
file_output = ''
if filesystem.isfile(driver_path):
# The --dereference flag tells file to follow symlinks
file_output = executive.run_command(['file', '--brief', '--dereference', driver_path], return_stderr=True)
if re.match(r'ELF 32-bit LSB\s+executable', file_output):
return 'x86'
if re.match(r'ELF 64-bit LSB\s+executable', file_output):
return 'x86_64'
if file_output:
_log.warning('Could not determine architecture from "file" output: %s' % file_output)
# We don't know what the architecture is; default to 'x86' because
# maybe we're rebaselining and the binary doesn't actually exist,
# or something else weird is going on. It's okay to do this because
# if we actually try to use the binary, check_build() should fail.
return 'x86_64'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
return port_name + '-' + cls._determine_architecture(host.filesystem, host.executive, cls._determine_driver_path_statically(host, options))
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
(base, arch) = port_name.rsplit('-', 1)
assert base == 'linux'
assert arch in self.SUPPORTED_VERSIONS
assert port_name in ('linux', 'linux-x86', 'linux-x86_64')
self._version = 'lucid' # We only support lucid right now.
self._architecture = arch
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def additional_drt_flag(self):
flags = super(LinuxPort, self).additional_drt_flag()
if not self.get_option('disable_breakpad'):
flags += ['--enable-crash-reporter', '--crash-dumps-dir=%s' % self._dump_reader.crash_dumps_directory()]
return flags
def default_baseline_search_path(self):
port_names = self.FALLBACK_PATHS[self._architecture]
return map(self._webkit_baseline_path, port_names)
def _modules_to_search_for_symbols(self):
return [self._build_path('libffmpegsumo.so')]
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(' http://code.google.com/p/chromium/wiki/LinuxBuildInstructions')
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def virtual_test_suites(self):
result = super(LinuxPort, self).virtual_test_suites()
result.extend([
base.VirtualTestSuite('linux-subpixel',
'platform/linux/fast/text/subpixel',
['--enable-webkit-text-subpixel-positioning']),
])
return result
#
# PROTECTED METHODS
#
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(), "apache2 config file") and result
if not result:
_log.error(' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"')
_log.error('')
return result
def _check_lighttpd_install(self):
result = self._check_file_exists(
self._path_to_lighttpd(), "LigHTTPd executable")
result = self._check_file_exists(self._path_to_lighttpd_php(), "PHP CGI executable") and result
result = self._check_file_exists(self._path_to_lighttpd_modules(), "LigHTTPd modules") and result
if not result:
_log.error(' Please install using: "sudo apt-get install lighttpd php5-cgi"')
_log.error('')
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
def path_to_lighttpd(self):
return "/usr/sbin/lighttpd"
def path_to_lighttpd_modules(self):
return "/usr/lib/lighttpd"
def path_to_lighttpd_php(self):
return "/usr/bin/php-cgi"
def _path_to_driver(self, configuration=None):
binary_name = self.driver_name()
return self._build_path_with_configuration(configuration, binary_name)
def _path_to_helper(self):
return None
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('trusty',)
FALLBACK_PATHS = {}
FALLBACK_PATHS['trusty'] = ['linux'] + win.WinPort.latest_platform_fallback_path()
BUILD_REQUIREMENTS_URL = 'https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md'
XVFB_START_TIMEOUT = 5.0 # Wait up to 5 seconds for Xvfb to start.
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
assert host.platform.is_linux()
version = host.platform.os_version
return port_name + '-' + version
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = 'x86_64'
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
self._original_home = None
self._original_display = None
self._xvfb_process = None
self._xvfb_stdout = None
self._xvfb_stderr = None
def additional_driver_flags(self):
flags = super(LinuxPort, self).additional_driver_flags()
if not self.get_option('disable_breakpad'):
flags += ['--enable-crash-reporter', '--crash-dumps-dir=%s' % self._dump_reader.crash_dumps_directory()]
return flags
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(' https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md')
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ['/usr/sbin/httpd', '/usr/sbin/apache2']:
if self._filesystem.exists(path):
return path
_log.error('Could not find apache. Not installed or unknown path.')
return None
def setup_test_run(self):
super(LinuxPort, self).setup_test_run()
self._start_xvfb()
self._setup_dummy_home_dir()
def clean_up_test_run(self):
super(LinuxPort, self).clean_up_test_run()
self._stop_xvfb(save_logs=False)
self._clean_up_dummy_home_dir()
#
# PROTECTED METHODS
#
def _setup_dummy_home_dir(self):
"""Creates a dummy home directory for running the test.
This is a workaround for crbug.com/595504; see crbug.com/612730.
If crbug.com/612730 is resolved in another way, then this may be
unnecessary.
"""
self._original_home = self.host.environ.get('HOME')
dummy_home = str(self._filesystem.mkdtemp())
self.host.environ['HOME'] = dummy_home
self._setup_files_in_dummy_home_dir(dummy_home)
def _setup_files_in_dummy_home_dir(self, dummy_home):
# Note: This may be unnecessary.
fs = self._filesystem
for filename in ['.Xauthority']:
original_path = fs.join(self._original_home, filename)
if not fs.exists(original_path):
continue
fs.copyfile(original_path, fs.join(dummy_home, filename))
# Prevent fontconfig etc. from reconstructing the cache.
for dirname in ['.cache']:
original_path = fs.join(self._original_home, dirname)
if not fs.exists(original_path):
continue
fs.symlink(original_path, fs.join(dummy_home, dirname))
def _clean_up_dummy_home_dir(self):
"""Cleans up the dummy dir and resets the HOME environment variable."""
dummy_home = self.host.environ['HOME']
assert dummy_home != self._original_home
self._filesystem.rmtree(dummy_home)
self.host.environ['HOME'] = self._original_home
def _start_xvfb(self):
display = self._find_display()
if not display:
_log.critical('Failed to find a free display to start Xvfb.')
return
# Parts of Xvfb use a hard-coded "/tmp" for its temporary directory.
# This can cause a failure when those parts expect to hardlink against
# files that were created in "TEMPDIR" / "TMPDIR".
#
# See: https://crbug.com/715848
env = self.host.environ.copy()
if env.get('TMPDIR') and env['TMPDIR'] != '/tmp':
_log.info('Overriding TMPDIR to "/tmp" for Xvfb, was: %s', env['TMPDIR'])
env['TMPDIR'] = '/tmp'
_log.debug('Starting Xvfb with display "%s".', display)
self._xvfb_stdout = tempfile.NamedTemporaryFile(delete=False)
self._xvfb_stderr = tempfile.NamedTemporaryFile(delete=False)
self._xvfb_process = self.host.executive.popen(
['Xvfb', display, '-screen', '0', '1280x800x24', '-ac', '-dpi', '96'],
stdout=self._xvfb_stdout, stderr=self._xvfb_stderr, env=env)
# By setting DISPLAY here, the individual worker processes will
# get the right DISPLAY. Note, if this environment could be passed
# when creating workers, then we wouldn't need to modify DISPLAY here.
self._original_display = self.host.environ.get('DISPLAY')
self.host.environ['DISPLAY'] = display
# Check that xvfb has started correctly via probing using xdpyinfo.
# While xvfb is running, the poll() method will return None;
# https://docs.python.org/2/library/subprocess.html#subprocess.Popen.poll
start_time = self.host.time()
while self.host.time() - start_time < self.XVFB_START_TIMEOUT:
if self._xvfb_process.poll() is not None:
break
# We don't explicitly set the display, as we want to check the
# environment value.
exit_code = self.host.executive.run_command(
['xdpyinfo'], return_exit_code=True)
if exit_code == 0:
_log.debug('Successfully started Xvfb with display "%s".', display)
return
_log.warn('xdpyinfo check failed with exit code %s while starting Xvfb on "%s".', exit_code, display)
self.host.sleep(0.1)
retcode = self._xvfb_process.poll()
self._stop_xvfb(save_logs=True)
_log.critical('Failed to start Xvfb on display "%s" (xvfb retcode: %r).', display, retcode)
def _find_display(self):
"""Tries to find a free X display, looping if necessary."""
# The "xvfb-run" command uses :99 by default.
for display_number in range(99, 120):
display = ':%d' % display_number
exit_code = self.host.executive.run_command(
['xdpyinfo', '-display', display], return_exit_code=True)
if exit_code == 1:
return display
return None
def _stop_xvfb(self, save_logs):
if self._original_display:
self.host.environ['DISPLAY'] = self._original_display
if self._xvfb_stdout:
self._xvfb_stdout.close()
if self._xvfb_stderr:
self._xvfb_stderr.close()
if self._xvfb_process and self._xvfb_process.poll() is None:
_log.debug('Killing Xvfb process pid %d.', self._xvfb_process.pid)
self._xvfb_process.kill()
self._xvfb_process.wait()
if save_logs and self._xvfb_stdout and self.host.filesystem.exists(self._xvfb_stdout.name):
for line in self.host.filesystem.read_text_file(self._xvfb_stdout.name).splitlines():
_log.warn('Xvfb stdout: %s', line)
self.host.filesystem.remove(self._xvfb_stdout.name)
if save_logs and self._xvfb_stderr and self.host.filesystem.exists(self._xvfb_stderr.name):
for line in self.host.filesystem.read_text_file(self._xvfb_stderr.name).splitlines():
_log.warn('Xvfb stderr: %s', line)
self.host.filesystem.remove(self._xvfb_stderr.name)
self._xvfb_stdout = self._xvfb_stderr = self._xvfb_process = None
def _path_to_driver(self, target=None):
binary_name = self.driver_name()
return self._build_path_with_target(target, binary_name)
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('trusty',)
FALLBACK_PATHS = {}
FALLBACK_PATHS['trusty'] = ['linux'] + win.WinPort.latest_platform_fallback_path()
DEFAULT_BUILD_DIRECTORIES = ('out',)
BUILD_REQUIREMENTS_URL = 'https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
assert host.platform.is_linux()
version = host.platform.os_version
return port_name + '-' + version
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = 'x86_64'
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
self._original_home = None
def additional_driver_flag(self):
flags = super(LinuxPort, self).additional_driver_flag()
if not self.get_option('disable_breakpad'):
flags += ['--enable-crash-reporter', '--crash-dumps-dir=%s' % self._dump_reader.crash_dumps_directory()]
return flags
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(' https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md')
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ['/usr/sbin/httpd', '/usr/sbin/apache2']:
if self._filesystem.exists(path):
return path
_log.error('Could not find apache. Not installed or unknown path.')
return None
def setup_test_run(self):
super(LinuxPort, self).setup_test_run()
self._setup_dummy_home_dir()
def clean_up_test_run(self):
super(LinuxPort, self).clean_up_test_run()
self._clean_up_dummy_home_dir()
#
# PROTECTED METHODS
#
def _setup_dummy_home_dir(self):
"""Creates a dummy home directory for running the test.
This is a workaround for crbug.com/595504; see crbug.com/612730.
If crbug.com/612730 is resolved in another way, then this may be
unnecessary.
"""
self._original_home = self.host.environ.get('HOME')
dummy_home = str(self._filesystem.mkdtemp())
self.host.environ['HOME'] = dummy_home
self._copy_files_to_dummy_home_dir(dummy_home)
def _copy_files_to_dummy_home_dir(self, dummy_home):
# Note: This may be unnecessary.
fs = self._filesystem
for filename in ['.Xauthority']:
original_path = fs.join(self._original_home, filename)
if not fs.exists(original_path):
continue
fs.copyfile(original_path, fs.join(dummy_home, filename))
def _clean_up_dummy_home_dir(self):
"""Cleans up the dummy dir and resets the HOME environment variable."""
dummy_home = self.host.environ['HOME']
assert dummy_home != self._original_home
self._filesystem.rmtree(dummy_home)
self.host.environ['HOME'] = self._original_home
def _path_to_driver(self, target=None):
binary_name = self.driver_name()
return self._build_path_with_target(target, binary_name)
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('precise', 'trusty')
FALLBACK_PATHS = {}
FALLBACK_PATHS['trusty'] = ['linux'] + win.WinPort.latest_platform_fallback_path()
FALLBACK_PATHS['precise'] = ['linux-precise'] + FALLBACK_PATHS['trusty']
DEFAULT_BUILD_DIRECTORIES = ('out',)
BUILD_REQUIREMENTS_URL = 'https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
assert host.platform.is_linux()
version = host.platform.os_version
return port_name + '-' + version
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
self._version = port_name[port_name.index('linux-') + len('linux-'):]
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
self._original_home = None
def additional_driver_flag(self):
flags = super(LinuxPort, self).additional_driver_flag()
if not self.get_option('disable_breakpad'):
flags += ['--enable-crash-reporter', '--crash-dumps-dir=%s' % self._dump_reader.crash_dumps_directory()]
return flags
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(' https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md')
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
def setup_test_run(self):
super(LinuxPort, self).setup_test_run()
self._setup_dummy_home_dir()
def clean_up_test_run(self):
super(LinuxPort, self).clean_up_test_run()
self._clean_up_dummy_home_dir()
#
# PROTECTED METHODS
#
def _setup_dummy_home_dir(self):
"""Creates a dummy home directory for running the test.
This is a workaround for crbug.com/595504; see crbug.com/612730.
If crbug.com/612730 is resolved in another way, then this may be
unnecessary.
"""
self._original_home = self.host.environ.get('HOME')
dummy_home = str(self._filesystem.mkdtemp())
self.host.environ['HOME'] = dummy_home
self._copy_files_to_dummy_home_dir(dummy_home)
def _copy_files_to_dummy_home_dir(self, dummy_home):
# Note: This may be unnecessary.
fs = self._filesystem
for filename in ['.Xauthority']:
original_path = fs.join(self._original_home, filename)
if not fs.exists(original_path):
continue
fs.copyfile(original_path, fs.join(dummy_home, filename))
def _clean_up_dummy_home_dir(self):
"""Cleans up the dummy dir and resets the HOME environment variable."""
dummy_home = self.host.environ['HOME']
assert dummy_home != self._original_home
self._filesystem.rmtree(dummy_home)
self.host.environ['HOME'] = self._original_home
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(), "apache2 config file") and result
if not result:
_log.error(' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"')
_log.error('')
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def _path_to_driver(self, target=None):
binary_name = self.driver_name()
return self._build_path_with_target(target, binary_name)
class LinuxPort(base.Port):
port_name = 'linux'
SUPPORTED_VERSIONS = ('linux32', 'precise', 'trusty')
FALLBACK_PATHS = {}
FALLBACK_PATHS['trusty'] = ['linux'] + win.WinPort.latest_platform_fallback_path()
FALLBACK_PATHS['precise'] = ['linux-precise'] + FALLBACK_PATHS['trusty']
FALLBACK_PATHS['linux32'] = ['linux-x86'] + FALLBACK_PATHS['precise']
DEFAULT_BUILD_DIRECTORIES = ('out',)
BUILD_REQUIREMENTS_URL = 'https://code.google.com/p/chromium/wiki/LinuxBuildInstructions'
@classmethod
def _determine_driver_path_statically(cls, host, options):
config_object = config.Config(host.executive, host.filesystem)
build_directory = getattr(options, 'build_directory', None)
finder = WebKitFinder(host.filesystem)
webkit_base = finder.webkit_base()
chromium_base = finder.chromium_base()
driver_name = getattr(options, 'driver_name', None)
if driver_name is None:
driver_name = cls.CONTENT_SHELL_NAME
if hasattr(options, 'configuration') and options.configuration:
configuration = options.configuration
else:
configuration = config_object.default_configuration()
return cls._static_build_path(host.filesystem, build_directory, chromium_base, configuration, [driver_name])
@staticmethod
def _determine_architecture(filesystem, executive, driver_path):
file_output = ''
if filesystem.isfile(driver_path):
# The --dereference flag tells file to follow symlinks
file_output = executive.run_command(['file', '--brief', '--dereference', driver_path], return_stderr=True)
if re.match(r'ELF 32-bit LSB\s+(executable|shared object)', file_output):
return 'x86'
if re.match(r'ELF 64-bit LSB\s+(executable|shared object)', file_output):
return 'x86_64'
if file_output:
_log.warning('Could not determine architecture from "file" output: %s' % file_output)
# We don't know what the architecture is; default to 'x86_64' because
# maybe we're rebaselining and the binary doesn't actually exist,
# or something else weird is going on. It's okay to do this because
# if we actually try to use the binary, check_build() should fail.
return 'x86_64'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
if port_name.endswith('linux'):
arch = cls._determine_architecture(host.filesystem, host.executive,
cls._determine_driver_path_statically(host, options))
if arch == 'x86':
return port_name + '-x86'
else:
return port_name + '-' + host.platform.os_version # e.g. linux-trusty
return port_name
def __init__(self, host, port_name, **kwargs):
super(LinuxPort, self).__init__(host, port_name, **kwargs)
# FIXME: Rename 32-bit port name from linux-x86 to linux-linux32 to avoid confusion.
assert port_name.startswith('linux-')
port_name_suffix = port_name.replace('linux-', '', 1)
if port_name_suffix == "x86":
self._version = "linux32"
self._architecture = "x86"
else:
self._version = port_name_suffix
self._architecture = "x86_64"
assert self._version in self.SUPPORTED_VERSIONS
if not self.get_option('disable_breakpad'):
self._dump_reader = DumpReaderLinux(host, self._build_path())
def additional_driver_flag(self):
flags = super(LinuxPort, self).additional_driver_flag()
if not self.get_option('disable_breakpad'):
flags += ['--enable-crash-reporter', '--crash-dumps-dir=%s' % self._dump_reader.crash_dumps_directory()]
return flags
def _modules_to_search_for_symbols(self):
return [self._build_path('libffmpegsumo.so')]
def check_build(self, needs_http, printer):
result = super(LinuxPort, self).check_build(needs_http, printer)
if result:
_log.error('For complete Linux build requirements, please see:')
_log.error('')
_log.error(' http://code.google.com/p/chromium/wiki/LinuxBuildInstructions')
return result
def look_for_new_crash_logs(self, crashed_processes, start_time):
if self.get_option('disable_breakpad'):
return None
return self._dump_reader.look_for_new_crash_logs(crashed_processes, start_time)
def clobber_old_port_specific_results(self):
if not self.get_option('disable_breakpad'):
self._dump_reader.clobber_old_results()
def operating_system(self):
return 'linux'
def path_to_apache(self):
# The Apache binary path can vary depending on OS and distribution
# See http://wiki.apache.org/httpd/DistrosDefaultLayout
for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
if self._filesystem.exists(path):
return path
_log.error("Could not find apache. Not installed or unknown path.")
return None
#
# PROTECTED METHODS
#
def _check_apache_install(self):
result = self._check_file_exists(self.path_to_apache(), "apache2")
result = self._check_file_exists(self.path_to_apache_config_file(), "apache2 config file") and result
if not result:
_log.error(' Please install using: "sudo apt-get install apache2 libapache2-mod-php5"')
_log.error('')
return result
def _wdiff_missing_message(self):
return 'wdiff is not installed; please install using "sudo apt-get install wdiff"'
def _path_to_driver(self, configuration=None):
binary_name = self.driver_name()
return self._build_path_with_configuration(configuration, binary_name)
def _path_to_helper(self):
return None
