def archive(options, args):
build_dir, _ = chromium_utils.ConvertBuildDirToLegacy(
options.build_dir, use_out=chromium_utils.IsLinux())
build_dir = os.path.join(build_dir, options.target)
src_dir = os.path.abspath(os.path.dirname(options.build_dir))
staging_dir = slave_utils.GetStagingDir(src_dir)
build_revision = slave_utils.SubversionRevision(src_dir)
chromium_utils.MakeParentDirectoriesWorldReadable(staging_dir)
print 'Staging in %s' % build_dir
# Build the list of files to archive.
zip_file_list = [
f for f in os.listdir(build_dir)
if ShouldPackageFile(f, options.target)
]
subdir = None
# TODO(nsylvain): We need to move linux to a subdir as well, but aarya is not
# ready with the server-side change.
if chromium_utils.IsMac():
subdir = '%s-%s' % (chromium_utils.PlatformName(),
options.target.lower())
prefix = options.factory_properties.get('cf_archive_name', 'cf_archive')
zip_file_name = '%s-%s-%s-%d' % (prefix, chromium_utils.PlatformName(),
options.target.lower(), build_revision)
(zip_dir, zip_file) = chromium_utils.MakeZip(staging_dir,
zip_file_name,
zip_file_list,
build_dir,
raise_error=True)
chromium_utils.RemoveDirectory(zip_dir)
if not os.path.exists(zip_file):
raise StagingError('Failed to make zip package %s' % zip_file)
chromium_utils.MakeWorldReadable(zip_file)
# Report the size of the zip file to help catch when it gets too big.
zip_size = os.stat(zip_file)[stat.ST_SIZE]
print 'Zip file is %ld bytes' % zip_size
gs_bucket = options.factory_properties.get('gs_bucket', None)
gs_acl = options.factory_properties.get('gs_acl', None)
status = slave_utils.GSUtilCopyFile(zip_file,
gs_bucket,
subdir=subdir,
gs_acl=gs_acl)
if status:
raise StagingError('Failed to upload %s to %s. Error %d' %
(zip_file, gs_bucket, status))
else:
# Delete the file, it is not needed anymore.
os.remove(zip_file)
return status
def run_benchmark(options, use_refbuild, benchmark_results):
build_dir, bad = chromium_utils.ConvertBuildDirToLegacy(options.build_dir)
build_dir = os.path.abspath(options.build_dir)
result = slave_utils.WARNING_EXIT_CODE if bad else 0
if not use_refbuild:
build_dir = os.path.join(build_dir, options.target)
else:
build_dir = os.path.join(os.path.dirname(build_dir), 'chrome', 'tools',
'test', 'reference_build')
if chromium_utils.IsMac():
build_dir = os.path.join(build_dir, 'chrome_mac')
elif chromium_utils.IsLinux():
build_dir = os.path.join(build_dir, 'chrome_linux')
else:
build_dir = os.path.join(build_dir, 'chrome_win')
if chromium_utils.IsWindows():
chrome_exe_name = 'chrome.exe'
elif chromium_utils.IsLinux():
chrome_exe_name = 'chrome'
else:
chrome_exe_name = 'Chromium'
chrome_exe_path = os.path.join(build_dir, chrome_exe_name)
if not os.path.exists(chrome_exe_path):
raise chromium_utils.PathNotFound('Unable to find %s' %
chrome_exe_path)
temp_dir = tempfile.mkdtemp()
command = [
chrome_exe_path,
'--user-data-dir=%s' % temp_dir, '--no-first-run',
'--no-default-browser-check', START_URL
]
print "Executing: "
print command
browser_process = subprocess.Popen(command)
benchmark_results['ready'].wait()
if benchmark_results['ready'].isSet():
results = json.loads(benchmark_results['results'])[0]
print_result(True, 'Total', results['score'], use_refbuild)
for child in results['children']:
print_result(False, child['name'], child['score'], use_refbuild)
benchmark_results['ready'].clear()
if chromium_utils.IsWindows():
subprocess.call('taskkill /f /pid %i /t' % browser_process.pid)
else:
os.system('kill -15 %i' % browser_process.pid)
browser_process.wait()
shutil.rmtree(temp_dir)
return result
def main_linux(options, args):
"""Print appropriate size information about built Linux targets.
Returns the first non-zero exit status of any command it executes,
or zero on success.
"""
build_dir, _ = chromium_utils.ConvertBuildDirToLegacy(options.build_dir)
target_dir = os.path.join(build_dir, options.target)
binaries = [
'chrome',
'nacl_helper',
'nacl_helper_bootstrap',
'libffmpegsumo.so',
'libgcflashplayer.so',
'libpdf.so',
'libppGoogleNaClPluginChrome.so',
]
result = 0
totals = {}
for binary in binaries:
this_result, this_sizes = check_linux_binary(target_dir, binary,
options)
if result == 0:
result = this_result
for name, identifier, totals_id, value, units in this_sizes:
print 'RESULT %s: %s= %s %s' % (name, identifier, value, units)
totals_id = totals_id or identifier, units
totals[totals_id] = totals.get(totals_id, 0) + int(value)
files = [
'chrome.pak',
'nacl_irt_x86_64.nexe',
]
for filename in files:
path = os.path.join(target_dir, filename)
try:
size = get_size(path)
except OSError, e:
if e.errno == errno.ENOENT:
continue # Don't print anything for missing files.
raise
print 'RESULT %s: %s= %s bytes' % (filename, filename, size)
totals['size', 'bytes'] += size
def AddIsolateTest(self, test_name, using_ninja):
if not self._target:
log.msg('No target specified, unable to find isolated files')
return
isolated_directory, _ = chromium_utils.ConvertBuildDirToLegacy(
self._build_dir,
target_platform=self._target_platform,
use_out=(using_ninja or self._target_platform.startswith('linux')))
isolated_directory = self.PathJoin(isolated_directory, self._target)
isolated_file = self.PathJoin(isolated_directory,
test_name + '.isolated')
script_path = self.PathJoin(self._swarming_client_dir, 'isolate.py')
args = ['run', '--isolated', isolated_file, '--', '--no-cr']
wrapper_args = ['--annotate=gtest', '--test-type=%s' % test_name]
command = self.GetPythonTestCommand(script_path,
arg_list=args,
wrapper_args=wrapper_args)
self.AddTestStep(chromium_step.AnnotatedCommand, test_name, command)
def main():
option_parser = optparse.OptionParser()
option_parser.add_option('--target',
help='build target to archive (Debug or Release)')
option_parser.add_option(
'--build-dir',
help='path to main build directory (the parent of '
'the Release or Debug directory)')
option_parser.add_option('--build-url',
help='url where to find the build to extract')
option_parser.add_option('--build-output-dir',
help='Output path relative to --build-dir.')
option_parser.add_option('--revision', help='Revision number to download.')
chromium_utils.AddPropertiesOptions(option_parser)
options, args = option_parser.parse_args()
if args:
print 'Unknown options: %s' % args
return 1
if options.build_output_dir:
options.build_output_dir = os.path.join(options.build_dir,
options.build_output_dir)
else:
options.build_output_dir, bad = chromium_utils.ConvertBuildDirToLegacy(
options.build_dir)
if bad:
return slave_utils.WARNING_EXIT_CODE
options.build_output_dir = os.path.abspath(options.build_output_dir)
options.build_url = (options.build_url
or options.factory_properties.get('build_url'))
del options.factory_properties
del options.build_properties
return real_main(options)
def __init__(self, options, build_revision):
"""Sets a number of file and directory paths for convenient use."""
self.options = options
self._src_dir = os.path.abspath(options.src_dir)
self._chrome_dir = os.path.join(self._src_dir, 'chrome')
# TODO: This scode should not be grabbing so deeply into WebKit.
# Worse, this code ends up looking at top-of-tree WebKit
# instead of the revision in DEPS.
self._webkit_dir = os.path.join(self._src_dir, 'third_party', 'WebKit',
'Source')
self._v8_dir = os.path.join(self._src_dir, 'v8')
build_dir, _ = chromium_utils.ConvertBuildDirToLegacy(
options.build_dir, use_out=chromium_utils.IsLinux())
self._build_dir = os.path.join(build_dir, options.target)
if chromium_utils.IsWindows():
self._tool_dir = os.path.join(self._chrome_dir, 'tools', 'build',
'win')
elif chromium_utils.IsLinux():
# On Linux, we might have built for chromeos. Archive the same.
if (options.factory_properties.get('chromeos', None)
or slave_utils.GypFlagIsOn(options, 'chromeos')):
self._tool_dir = os.path.join(self._chrome_dir, 'tools',
'build', 'chromeos')
# Or, we might have built for Android.
elif options.factory_properties.get('target_os') == 'android':
self._tool_dir = os.path.join(self._chrome_dir, 'tools',
'build', 'android')
else:
self._tool_dir = os.path.join(self._chrome_dir, 'tools',
'build', 'linux')
elif chromium_utils.IsMac():
self._tool_dir = os.path.join(self._chrome_dir, 'tools', 'build',
'mac')
else:
raise NotImplementedError(
'Platform "%s" is not currently supported.' % sys.platform)
self._staging_dir = slave_utils.GetStagingDir(self._src_dir)
self._symbol_dir_base = options.dirs['symbol_dir_base']
self._www_dir_base = options.dirs['www_dir_base']
self._build_name = slave_utils.SlaveBuildName(self._src_dir)
self._symbol_dir_base = os.path.join(self._symbol_dir_base,
self._build_name)
self._www_dir_base = os.path.join(self._www_dir_base, self._build_name)
self._version_file = os.path.join(self._chrome_dir, 'VERSION')
if options.default_chromium_revision:
self._chromium_revision = options.default_chromium_revision
else:
self._chromium_revision = slave_utils.GetHashOrRevision(
os.path.dirname(
self._chrome_dir)) # src/ instead of src/chrome
if options.default_webkit_revision:
self._webkit_revision = options.default_webkit_revision
else:
self._webkit_revision = slave_utils.GetHashOrRevision(
os.path.dirname(
self._webkit_dir)) # WebKit/ instead of WebKit/Source
if options.default_v8_revision:
self._v8_revision = options.default_v8_revision
else:
self._v8_revision = slave_utils.GetHashOrRevision(self._v8_dir)
self.last_change_file = os.path.join(self._staging_dir, 'LAST_CHANGE')
# The REVISIONS file will record the revisions information of the main
# components Chromium/WebKit/V8.
self.revisions_path = os.path.join(self._staging_dir, 'REVISIONS')
self._build_revision = build_revision
# Will be initialized in GetLastBuildRevision.
self.last_chromium_revision = None
self.last_webkit_revision = None
self.last_v8_revision = None
self._files_file = os.path.join(self._tool_dir,
archive_utils.FILES_FILENAME)
self._test_files = self.BuildOldFilesList(TEST_FILE_NAME)
self._dual_upload = options.factory_properties.get(
'dual_upload', False)
self._archive_files = None
def real_main(options):
""" Download a build, extract it to build\BuildDir\full-build-win32
and rename it to build\BuildDir\Target
"""
normal_retval = 0
if options.build_output_dir:
build_output_dir = os.path.join(options.build_dir, options.build_output_dir)
else:
build_output_dir, bad = chromium_utils.ConvertBuildDirToLegacy(
options.build_dir)
if bad:
normal_retval = slave_utils.WARNING_EXIT_CODE
abs_build_dir = os.path.abspath(options.build_dir)
abs_build_output_dir = os.path.abspath(build_output_dir)
target_build_output_dir = os.path.join(abs_build_output_dir, options.target)
# Generic name for the archive.
archive_name = 'full-build-%s.zip' % chromium_utils.PlatformName()
# Just take the zip off the name for the output directory name.
output_dir = os.path.join(abs_build_output_dir,
archive_name.replace('.zip', ''))
base_url, url = GetBuildUrl(abs_build_dir, options)
archive_name = os.path.basename(base_url)
if url.startswith('gs://'):
handler = GSHandler(url=url, archive_name=archive_name)
else:
handler = WebHandler(url=url, archive_name=archive_name)
# We try to download and extract 3 times.
for tries in range(1, 4):
print 'Try %d: Fetching build from %s...' % (tries, url)
failure = False
# Check if the url exists.
if not handler.is_present():
print '%s is not found' % url
failure = True
# When 'halt_on_missing_build' is present in factory_properties and if
# 'revision' is set in build properties, we assume the build is
# triggered automatically and so we halt on a missing build zip. The
# other case is if the build is forced, in which case we keep trying
# later by looking for the latest build that's available.
if (options.factory_properties.get('halt_on_missing_build', False) and
'revision' in options.build_properties and
options.build_properties['revision'] != ''):
return slave_utils.ERROR_EXIT_CODE
# If the url is valid, we download the file.
if not failure:
if not handler.download():
failure = True
# If the versioned url failed, we try to get the latest build.
if failure:
if url.startswith('gs://'):
continue
else:
print 'Fetching latest build at %s' % base_url
handler.url = base_url
if not handler.download():
continue
print 'Extracting build %s to %s...' % (archive_name, abs_build_output_dir)
try:
chromium_utils.RemoveDirectory(target_build_output_dir)
chromium_utils.ExtractZip(archive_name, abs_build_output_dir)
# For Chrome builds, the build will be stored in chrome-win32.
if 'full-build-win32' in output_dir:
chrome_dir = output_dir.replace('full-build-win32', 'chrome-win32')
if os.path.exists(chrome_dir):
output_dir = chrome_dir
print 'Moving build from %s to %s' % (output_dir, target_build_output_dir)
shutil.move(output_dir, target_build_output_dir)
except (OSError, IOError, chromium_utils.ExternalError):
print 'Failed to extract the build.'
# Print out the traceback in a nice format
traceback.print_exc()
# Try again...
continue
# If we got the latest build, then figure out its revision number.
if failure:
print "Trying to determine the latest build's revision number..."
try:
build_revision_file_name = os.path.join(
target_build_output_dir,
chromium_utils.FULL_BUILD_REVISION_FILENAME)
build_revision_file = open(build_revision_file_name, 'r')
print 'Latest build is revision: %s' % build_revision_file.read()
build_revision_file.close()
except IOError:
print "Could not determine the latest build's revision number"
if failure:
# We successfully extracted the archive, but it was the generic one.
return slave_utils.WARNING_EXIT_CODE
return normal_retval
# If we get here, that means that it failed 3 times. We return a failure.
return slave_utils.ERROR_EXIT_CODE
def main_mac(options, args):
"""Print appropriate size information about built Mac targets.
Returns the first non-zero exit status of any command it executes,
or zero on success.
"""
out_dir_path = os.path.join(os.path.dirname(options.build_dir), 'out')
build_dir, _ = chromium_utils.ConvertBuildDirToLegacy(
options.build_dir, use_out=os.path.exists(out_dir_path))
target_dir = os.path.join(build_dir, options.target)
result = 0
# Work with either build type.
base_names = ('Chromium', 'Google Chrome')
for base_name in base_names:
app_bundle = base_name + '.app'
framework_name = base_name + ' Framework'
framework_bundle = framework_name + '.framework'
chromium_app_dir = os.path.join(target_dir, app_bundle)
chromium_executable = os.path.join(chromium_app_dir, 'Contents',
'MacOS', base_name)
chromium_framework_dir = os.path.join(target_dir, framework_bundle)
chromium_framework_executable = os.path.join(chromium_framework_dir,
framework_name)
if os.path.exists(chromium_executable):
print_dict = {
# Remove spaces in the names so any downstream processing is less
# likely to choke.
'app_name': re.sub('\s', '', base_name),
'app_bundle': re.sub('\s', '', app_bundle),
'framework_name': re.sub('\s', '', framework_name),
'framework_bundle': re.sub('\s', '', framework_bundle),
'app_size': get_size(chromium_executable),
'framework_size': get_size(chromium_framework_executable)
}
# Collect the segment info out of the App
p = subprocess.Popen(['size', chromium_executable],
stdout=subprocess.PIPE)
stdout = p.communicate()[0]
print_dict['app_text'], print_dict['app_data'], print_dict['app_objc'] = \
re.search('(\d+)\s+(\d+)\s+(\d+)', stdout).groups()
if result == 0:
result = p.returncode
# Collect the segment info out of the Framework
p = subprocess.Popen(['size', chromium_framework_executable],
stdout=subprocess.PIPE)
stdout = p.communicate()[0]
print_dict['framework_text'], print_dict['framework_data'], \
print_dict['framework_objc'] = \
re.search('(\d+)\s+(\d+)\s+(\d+)', stdout).groups()
if result == 0:
result = p.returncode
# Collect the whole size of the App bundle on disk (include the framework)
p = subprocess.Popen(['du', '-s', '-k', chromium_app_dir],
stdout=subprocess.PIPE)
stdout = p.communicate()[0]
du_s = re.search('(\d+)', stdout).group(1)
if result == 0:
result = p.returncode
print_dict['app_bundle_size'] = (int(du_s) * 1024)
# Count the number of files with at least one static initializer.
pipes = [['otool', '-l', chromium_framework_executable],
['grep', '__mod_init_func', '-C', '5'], ['grep', 'size']]
last_stdout = None
for pipe in pipes:
p = subprocess.Popen(pipe,
stdin=last_stdout,
stdout=subprocess.PIPE)
last_stdout = p.stdout
stdout = p.communicate()[0]
initializers_s = re.search('0x([0-9a-f]+)', stdout).group(1)
if result == 0:
result = p.returncode
word_size = 4 # Assume 32 bit
print_dict['initializers'] = int(initializers_s, 16) / word_size
print("""RESULT %(app_name)s: %(app_name)s= %(app_size)s bytes
RESULT %(app_name)s-__TEXT: __TEXT= %(app_text)s bytes
RESULT %(app_name)s-__DATA: __DATA= %(app_data)s bytes
RESULT %(app_name)s-__OBJC: __OBJC= %(app_objc)s bytes
RESULT %(framework_name)s: %(framework_name)s= %(framework_size)s bytes
RESULT %(framework_name)s-__TEXT: __TEXT= %(framework_text)s bytes
RESULT %(framework_name)s-__DATA: __DATA= %(framework_data)s bytes
RESULT %(framework_name)s-__OBJC: __OBJC= %(framework_objc)s bytes
RESULT %(app_bundle)s: %(app_bundle)s= %(app_bundle_size)s bytes
RESULT chrome-si: initializers= %(initializers)d files
""") % (print_dict)
# Found a match, don't check the other base_names.
return result
# If no base_names matched, fail script.
return 66