blob: 977d5fb03676687039003db7e4b019ee1e5a1043 [file] [log] [blame] [edit]
#!/usr/bin/env python
# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""A tool to archive a build and its symbols, executed by a buildbot slave.
This script is used for developer builds.
To archive files on Google Storage, set the --gs-bucket flag to
'gs://<bucket-name>'. To control access to archives, set the --gs-acl flag to
the desired canned-acl (e.g. 'public-read', see
https://developers.google.com/storage/docs/accesscontrol#extension for other
supported canned-acl values). If the --gs-acl flag is not set, the bucket's
default object ACL will be applied (see
https://developers.google.com/storage/docs/accesscontrol#defaultobjects).
When this is run, the current directory (cwd) should be the outer build
directory (e.g., chrome-release/build/).
For a list of command-line options, call this script with '--help'.
"""
import glob
import json
import optparse
import os
import sys
from common import archive_utils
from common.chromium_utils import GS_COMMIT_POSITION_NUMBER_KEY, \
GS_COMMIT_POSITION_KEY, \
GS_GIT_COMMIT_KEY
from common import chromium_utils
from recipes import build_directory
from recipes import slave_utils
# TODO(mmoss): tests should be added to FILES.cfg, then TESTS can go away.
# The names of the files containing the list of tests to be archived for the
# build. This file can be present in self._tool_dir as well as in the path
# specifed by --extra-archive-paths.
TEST_FILE_NAME = 'TESTS'
class GSUtilError(Exception):
pass
def Write(file_path, data):
f = open(file_path, 'w')
try:
f.write(data)
finally:
f.close()
class StagerBase(object):
"""Handles archiving a build. Call the public ArchiveBuild() method."""
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')
build_dir = build_directory.GetBuildOutputDirectory(self._src_dir or None)
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.target_os == 'chromeos':
self._tool_dir = os.path.join(
self._chrome_dir, 'tools', 'build', 'chromeos'
)
# Or, we might have built for Android.
elif options.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 = (
options.staging_dir or slave_utils.GetStagingDir(self._src_dir)
)
if not os.path.exists(self._staging_dir):
os.makedirs(self._staging_dir)
self._symbol_dir_base = options.dirs['symbol_dir_base']
self._www_dir_base = options.dirs['www_dir_base']
if options.build_name:
self._build_name = options.build_name
else:
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')
self._chromium_revision = chromium_utils.GetBuildSortKey(options)[1]
self._v8_revision = chromium_utils.GetBuildSortKey(options, project='v8')[1]
self._v8_revision_git = chromium_utils.GetGitCommit(options, project='v8')
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
self._build_path_component = str(self._build_revision)
# Will be initialized in GetLastBuildRevision.
self.last_chromium_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._archive_files = None
def CopyFileToGS(
self, filename, gs_base, gs_subdir, mimetype=None, gs_acl=None
):
# normalize the subdir to remove duplicated slashes. This break newer
# versions of gsutil. Also remove leading and ending slashes for the subdir,
# gsutil adds them back autimatically and this can cause a double slash to
# be added.
if gs_subdir:
gs_subdir = gs_subdir.replace('//', '/')
gs_subdir = gs_subdir.strip('/')
# Construct metadata from our revision information, as available.
gs_metadata = {
GS_COMMIT_POSITION_NUMBER_KEY: self._chromium_revision,
}
# Add the commit position, if available
try:
gs_metadata[GS_COMMIT_POSITION_KEY] = chromium_utils.BuildCommitPosition(
*chromium_utils.GetCommitPosition(self.options)
)
except chromium_utils.NoIdentifiedRevision:
pass
# Add the git commit hash, if available
try:
gs_metadata[GS_GIT_COMMIT_KEY] = chromium_utils.GetGitCommit(self.options)
except chromium_utils.NoIdentifiedRevision:
pass
status = slave_utils.GSUtilCopyFile(
filename, gs_base, gs_subdir, mimetype, gs_acl, metadata=gs_metadata
)
if status != 0:
dest = gs_base + '/' + gs_subdir
raise GSUtilError(
'GSUtilCopyFile error %d. "%s" -> "%s"' % (status, filename, dest)
)
def TargetPlatformName(self):
return self.options.target_os or chromium_utils.PlatformName()
def BuildOldFilesList(self, source_file_name):
"""Build list of files from the old "file of paths" style input.
Combine any source_file_name inputs found in the default tools dir and in
any dirs given with --extra-archive-paths.
"""
default_source = os.path.join(self._tool_dir, source_file_name)
if os.path.exists(default_source):
file_list = open(default_source).readlines()
else:
print 'WARNING: No default %s list found at %s' % (
source_file_name, default_source
)
file_list = []
file_list = [f.strip() for f in file_list]
file_list.extend(
self.GetExtraFiles(self.options.extra_archive_paths, source_file_name)
)
file_list = archive_utils.ExpandWildcards(self._build_dir, file_list)
return file_list
def MyCopyFileToDir(
self,
filename,
destination,
gs_base,
gs_subdir='',
mimetype=None,
gs_acl=None
):
if gs_base:
self.CopyFileToGS(
filename, gs_base, gs_subdir, mimetype=mimetype, gs_acl=gs_acl
)
if not gs_base:
chromium_utils.CopyFileToDir(filename, destination)
def MyMaybeMakeDirectory(self, destination, gs_base):
if not gs_base:
chromium_utils.MaybeMakeDirectory(destination)
def MyMakeWorldReadable(self, destination, gs_base):
if not gs_base:
chromium_utils.MakeWorldReadable(destination)
def MySshMakeDirectory(self, host, destination, gs_base):
if not gs_base:
chromium_utils.SshMakeDirectory(host, destination)
def MySshCopyFiles(
self,
filename,
host,
destination,
gs_base,
gs_subdir='',
mimetype=None,
gs_acl=None
):
if gs_base:
self.CopyFileToGS(
filename, gs_base, gs_subdir, mimetype=mimetype, gs_acl=gs_acl
)
if not gs_base:
chromium_utils.SshCopyFiles(filename, host, destination)
def GetExtraFiles(self, extra_archive_paths, source_file_name):
"""Returns a list of extra files to package in the build output directory.
For each of the paths in the extra_file_paths list, this function
checks to see if path/source_file_name exists. If so, it expects these
files to contain a list of newline-separated filenames that it returns
in a list. The paths in extra_archive_paths are relative to the
directory specified by --src-dir.
"""
extra_files_list = []
extra_path_list = extra_archive_paths.split(',')
for path in extra_path_list:
path = path.strip()
source_file = os.path.join(self._src_dir, path, source_file_name)
if os.path.exists(source_file):
new_files_list = open(source_file).readlines()
extra_files_list.extend(new_files_list)
extra_files_list = [e.strip() for e in extra_files_list]
extra_files_list = archive_utils.ExpandWildcards(
self._build_dir, extra_files_list
)
return extra_files_list
def GenerateRevisionFile(self):
"""Save chromium/webkit/v8's revision in a specified file. we will write a
human readable format to save the revision information. The contents will be
{"chromium_revision":chromium_revision,
"v8_revision":v8_revision}
It is also in json format.
"""
print 'Saving revision to %s' % self.revisions_path
Write(
self.revisions_path,
json.dumps({
'chromium_revision': self._chromium_revision,
'v8_revision': self._v8_revision,
'v8_revision_git': self._v8_revision_git,
})
)
def GetLastBuildRevision(self):
"""Reads the last staged build revision from last_change_file.
If the last_change_file does not exist, returns None.
We also try to get the last Chromium/WebKit/V8 revision from the REVISIONS
file generated by GenerateRevisionFile
"""
last_build_revision = None
if os.path.exists(self.last_change_file):
last_build_revision = open(self.last_change_file).read()
if os.path.exists(self.revisions_path):
fp = open(self.revisions_path)
try:
line = fp.readline()
# TODO(markhuang): remove this block after all builders are updated
line = line.replace('\'', '"')
revisions_dict = json.loads(line)
if revisions_dict:
self.last_chromium_revision = revisions_dict['chromium_revision']
self.last_v8_revision = revisions_dict['v8_revision']
except (IOError, KeyError, ValueError), e:
self.last_chromium_revision = None
self.last_v8_revision = None
print e
fp.close()
return last_build_revision
def SaveBuildRevisionToSpecifiedFile(self, file_path):
"""Save build revision in the specified file"""
print 'Saving revision to %s' % file_path
Write(file_path, '%s' % self._build_revision)
def CreateArchiveFile(self, zip_name, zip_file_list):
return archive_utils.CreateArchive(
self._build_dir, self._staging_dir, zip_file_list, zip_name
)
# TODO(mmoss): This could be simplified a bit if revisions_path were added to
# archive_files. The only difference in handling seems to be that Linux/Mac
# unlink archives after upload, but don't unlink those two files. Any reason
# why deleting them would be a problem? They don't appear to be used elsewhere
# in this script.
def _UploadBuild(
self, www_dir, revisions_path, archive_files, gs_base, gs_acl
):
if chromium_utils.IsWindows():
print 'os.makedirs(%s)' % www_dir
for archive in archive_files:
print 'chromium_utils.CopyFileToDir(%s, %s)' % (archive, www_dir)
print 'chromium_utils.CopyFileToDir(%s, %s)' % (revisions_path, www_dir)
if not self.options.dry_run:
self.MyMaybeMakeDirectory(www_dir, gs_base)
for archive in archive_files:
self.MyCopyFileToDir(archive, www_dir, gs_base, gs_acl=gs_acl)
self.MyCopyFileToDir(revisions_path, www_dir, gs_base, gs_acl=gs_acl)
elif chromium_utils.IsLinux() or chromium_utils.IsMac():
for archive in archive_files:
print 'SshCopyFiles(%s, %s, %s)' % (
archive, self.options.archive_host, www_dir
)
print 'SshCopyFiles(%s, %s, %s)' % (
revisions_path, self.options.archive_host, www_dir
)
if not self.options.dry_run:
print 'SshMakeDirectory(%s, %s)' % (self.options.archive_host, www_dir)
self.MySshMakeDirectory(self.options.archive_host, www_dir, gs_base)
for archive in archive_files:
self.MyMakeWorldReadable(archive, gs_base)
self.MySshCopyFiles(
archive,
self.options.archive_host,
www_dir,
gs_base,
gs_acl=gs_acl
)
os.unlink(archive)
# Files are created umask 077 by default, so make it world-readable
# before pushing to web server.
self.MyMakeWorldReadable(revisions_path, gs_base)
self.MySshCopyFiles(
revisions_path,
self.options.archive_host,
www_dir,
gs_base,
gs_acl=gs_acl
)
else:
raise NotImplementedError(
'Platform "%s" is not currently supported.' % sys.platform
)
def UploadTests(self, www_dir, gs_base, gs_acl):
test_file_list = self._test_files
if not test_file_list:
return
# Make test_file_list contain absolute paths.
test_file_list = [os.path.join(self._build_dir, f) for f in test_file_list]
UPLOAD_DIR = 'chrome-%s.test' % self.TargetPlatformName()
# Filter out those files that don't exist.
base_src_dir = os.path.join(self._build_dir, '')
for test_file in test_file_list[:]:
if os.path.exists(test_file):
relative_dir = os.path.dirname(test_file[len(base_src_dir):])
test_dir = os.path.join(www_dir, UPLOAD_DIR, relative_dir)
print 'chromium_utils.CopyFileToDir(%s, %s)' % (test_file, test_dir)
else:
print '%s does not exist and is skipped.' % test_file
test_file_list.remove(test_file)
# Extract the list of test paths that will be created. These paths need
# to be relative to the archive dir. We have to rebuild the relative
# list from the now-pruned absolute test_file_list.
relative_file_list = [tf[len(base_src_dir):] for tf in test_file_list]
test_dirs = archive_utils.ExtractDirsFromPaths(relative_file_list)
test_dirs = [os.path.join(www_dir, UPLOAD_DIR, d) for d in test_dirs]
root_test_dir = os.path.join(www_dir, UPLOAD_DIR)
print 'chromium_utils.MaybeMakeDirectory(%s)' % root_test_dir
for test_dir in test_dirs:
print 'chromium_utils.MaybeMakeDirectory(%s)' % test_dir
if not self.options.dry_run:
if chromium_utils.IsWindows():
# Use Samba on Windows.
self.MyMaybeMakeDirectory(root_test_dir, gs_base)
for test_dir in test_dirs:
self.MyMaybeMakeDirectory(test_dir, gs_base)
for test_file in test_file_list:
# TODO(robertshield): binaries and symbols are stored in a zip file
# via CreateArchiveFile. Tests should be too.
relative_dir = os.path.dirname(test_file[len(base_src_dir):])
test_dir = os.path.join(www_dir, UPLOAD_DIR, relative_dir)
self.MyCopyFileToDir(
test_file,
test_dir,
gs_base,
gs_subdir='/'.join([UPLOAD_DIR, relative_dir]),
gs_acl=gs_acl
)
else:
# Otherwise use scp.
self.MySshMakeDirectory(
self.options.archive_host, root_test_dir, gs_base
)
for test_dir in test_dirs:
self.MySshMakeDirectory(self.options.archive_host, test_dir, gs_base)
for test_file in test_file_list:
self.MyMakeWorldReadable(test_file, gs_base)
# TODO(robertshield): binaries and symbols are stored in a zip file
# via CreateArchiveFile. Tests should be too.
relative_dir = os.path.dirname(test_file[len(base_src_dir):])
test_dir = os.path.join(www_dir, UPLOAD_DIR, relative_dir)
self.MySshCopyFiles(
test_file,
self.options.archive_host,
test_dir,
gs_base,
gs_subdir='/'.join([UPLOAD_DIR, relative_dir]),
gs_acl=gs_acl
)
def ArchiveBuild(self):
"""Zips build files and uploads them, their symbols, and a change log."""
result = 0
if self._build_revision is None:
raise archive_utils.StagingError('No build revision was provided')
print 'Staging in %s' % self._staging_dir
fparser = archive_utils.FilesCfgParser(
self._files_file, self.options.mode, self.options.arch
)
files_list = fparser.ParseLegacyList()
self._archive_files = archive_utils.ExpandWildcards(
self._build_dir, files_list
)
archives_list = fparser.ParseArchiveLists()
archives_files_list = [
item['filename']
for sublist in archives_list.values()
for item in sublist
]
archives_files_list = archive_utils.ExpandWildcards(
self._build_dir, archives_files_list
)
# Check that all the files for all the archives exist.
all_files_list = self._archive_files + archives_files_list
all_files_list.append(self._version_file)
not_found = archive_utils.VerifyFiles(
all_files_list, self._build_dir, self.options.ignore
)
not_found_optional = []
for bad_fn in not_found[:]:
if fparser.IsOptional(bad_fn):
not_found_optional.append(bad_fn)
not_found.remove(bad_fn)
# Remove it from all file lists so we don't try to process it.
if bad_fn in self._archive_files:
self._archive_files.remove(bad_fn)
for archive_list in archives_list.values():
archive_list[:] = [x for x in archive_list if bad_fn != x['filename']]
# TODO(mmoss): Now that we can declare files optional in FILES.cfg, should
# we only allow not_found_optional, and fail on any leftover not_found
# files?
print 'last change: %s' % self._build_revision
print 'build name: %s' % self._build_name
archive_name = 'chrome-%s.zip' % self.TargetPlatformName()
archive_file = self.CreateArchiveFile(archive_name, self._archive_files)[1]
# Handle any custom archives.
# TODO(mmoss): Largely copied from stage_build.py. Maybe refactor more of
# this into archive_utils.py.
archive_files = [archive_file]
for archive_name in archives_list:
# The list might be empty if it was all 'not_found' optional files.
if not archives_list[archive_name]:
continue
if fparser.IsDirectArchive(archives_list[archive_name]):
fileobj = archives_list[archive_name][0]
# Copy the file to the path specified in archive_name, which might be
# different than the dirname or basename in 'filename' (allowed by
# 'direct_archive').
stage_subdir = os.path.dirname(archive_name)
stage_fn = os.path.basename(archive_name)
chromium_utils.MaybeMakeDirectory(
os.path.join(self._staging_dir, stage_subdir)
)
print 'chromium_utils.CopyFileToDir(%s, %s, dest_fn=%s)' % (
os.path.join(self._build_dir, fileobj['filename']),
os.path.join(self._staging_dir, stage_subdir), stage_fn
)
if not self.options.dry_run:
chromium_utils.CopyFileToDir(
os.path.join(self._build_dir, fileobj['filename']),
os.path.join(self._staging_dir, stage_subdir),
dest_fn=stage_fn
)
archive_files.append(os.path.join(self._staging_dir, archive_name))
else:
custom_archive = self.CreateArchiveFile(
archive_name, [f['filename'] for f in archives_list[archive_name]]
)[1]
print 'Adding %s to be archived.' % (custom_archive)
archive_files.append(custom_archive)
# Generate a revisions file which contains the Chromium/WebKit/V8's
# revision information.
self.GenerateRevisionFile()
www_dir = os.path.join(self._www_dir_base, self._build_path_component)
gs_bucket = self.options.gs_bucket
gs_acl = self.options.gs_acl
gs_base = None
if gs_bucket:
gs_base = '/'.join([
gs_bucket, self._build_name, self._build_path_component
])
self._UploadBuild(
www_dir, self.revisions_path, archive_files, gs_base, gs_acl
)
# Archive Linux packages (if any -- only created for Chrome builds).
if chromium_utils.IsLinux():
linux_packages = (
glob.glob(
os.path.join(
self._build_dir, '*-r%s_*.deb' % self._chromium_revision
)
)
)
linux_packages.extend(
glob.glob(
os.path.join(
self._build_dir, '*-%s.*.rpm' % self._chromium_revision
)
)
)
for package_file in linux_packages:
print 'SshCopyFiles(%s, %s, %s)' % (
package_file, self.options.archive_host, www_dir
)
if not self.options.dry_run:
print 'SshMakeDirectory(%s, %s)' % (self.options.archive_host, www_dir)
self.MySshMakeDirectory(self.options.archive_host, www_dir, gs_base)
for package_file in linux_packages:
self.MyMakeWorldReadable(package_file, gs_base)
self.MySshCopyFiles(
package_file,
self.options.archive_host,
www_dir,
gs_base,
gs_acl=gs_acl
)
# Cleanup archived packages, otherwise they keep accumlating since
# they have different filenames with each build.
os.unlink(package_file)
self.UploadTests(www_dir, gs_base, gs_acl)
if not self.options.dry_run:
# Save the current build revision locally so we can compute a changelog
# next time
self.SaveBuildRevisionToSpecifiedFile(self.last_change_file)
# Record the latest revision in the developer archive directory.
latest_file_path = os.path.join(self._www_dir_base, 'LATEST')
if chromium_utils.IsWindows():
print 'Saving revision to %s' % latest_file_path
if gs_base:
self.CopyFileToGS(
self.last_change_file,
gs_base,
'..',
mimetype='text/plain',
gs_acl=gs_acl
)
if not gs_base:
self.SaveBuildRevisionToSpecifiedFile(latest_file_path)
elif chromium_utils.IsLinux() or chromium_utils.IsMac():
# Files are created umask 077 by default, so make it world-readable
# before pushing to web server.
self.MyMakeWorldReadable(self.last_change_file, gs_base)
print 'Saving revision to %s:%s' % (
self.options.archive_host, latest_file_path
)
self.MySshCopyFiles(
self.last_change_file,
self.options.archive_host,
latest_file_path,
gs_base,
'..',
mimetype='text/plain',
gs_acl=gs_acl
)
else:
raise NotImplementedError(
'Platform "%s" is not currently supported.' % sys.platform
)
if len(not_found_optional):
sys.stderr.write(
'\n\nINFO: Optional File(s) not found: %s\n' %
', '.join(not_found_optional)
)
if len(not_found):
sys.stderr.write(
'\n\nWARNING: File(s) not found: %s\n' % ', '.join(not_found)
)
return result
class StagerByChromiumRevision(StagerBase):
"""Handles archiving a build. Call the public ArchiveBuild() method.
Archive a build according to its chromium revision if it is because of
the chromium change.
"""
def __init__(self, options):
"""Overwrite _build_revision for archiving build by Chromium revision."""
StagerBase.__init__(self, options, None)
self._build_revision = self._chromium_revision
self._build_path_component = chromium_utils.GetSortableUploadPathForSortKey(
*chromium_utils.GetBuildSortKey(options)
)
class StagerByBuildNumber(StagerBase):
"""Handles archiving a build. Call the public ArchiveBuild() method.
Archive a build according to the build number if it is because of
the changes happened on multiple components like chromium/webkit/v8.
"""
def __init__(self, options):
"""Overwrite _build_revision for archiving build by build number."""
StagerBase.__init__(self, options, options.build_number)
def main():
option_parser = optparse.OptionParser()
option_parser.add_option(
'--mode',
default='dev',
help='switch indicating how to archive build (dev is only valid value)'
)
option_parser.add_option(
'--target',
default='Release',
help='build target to archive (Debug or Release)'
)
option_parser.add_option('--target-os', help='os target to archive')
option_parser.add_option(
'--arch',
default=archive_utils.BuildArch(),
help='specify that target architecure of the build'
)
option_parser.add_option(
'--src-dir',
default='src',
help='path to the top-level sources directory'
)
option_parser.add_option('--build-dir', help='ignored')
option_parser.add_option(
'--extra-archive-paths',
default='',
help='comma-separated lists of paths containing '
'files named FILES, SYMBOLS and TESTS. These '
'files contain lists of extra files to be '
'that will be archived. The paths are relative '
'to the directory given in --src-dir.'
)
option_parser.add_option(
'--build-number',
type='int',
help='The build number of the builder running '
'this script. we use it as the name of build '
'archive directory'
)
option_parser.add_option(
'--dry-run',
action='store_true',
help='Avoid making changes, for testing'
)
option_parser.add_option(
'--ignore', default=[], action='append', help='Files to ignore'
)
option_parser.add_option(
'--archive_host', default=archive_utils.Config.archive_host
)
option_parser.add_option(
'--gs-bucket', help='The Google Storage bucket to archive the build to'
)
option_parser.add_option(
'--gs-acl', help='The Google Storage ACL to apply to the archived build'
)
option_parser.add_option(
'--build-name',
default=None,
help="Name to use for build directory instead of "
"the slave build name"
)
option_parser.add_option(
'--staging-dir',
help='Directory to use for staging the archives. '
'Default behavior is to automatically detect '
'slave\'s build directory.'
)
chromium_utils.AddPropertiesOptions(option_parser)
slave_utils_callback = slave_utils.AddOpts(option_parser)
options, args = option_parser.parse_args()
if args:
raise archive_utils.StagingError('Unknown arguments: %s' % args)
slave_utils_callback(options)
if not options.ignore:
# Independent of any other configuration, these exes and any symbol files
# derived from them (i.e., any filename starting with these strings) will
# not be archived or uploaded, typically because they're not built for the
# current distributon.
options.ignore = archive_utils.Config.exes_to_skip_entirely
if options.mode == 'official':
option_parser.error('Official mode is not supported here')
elif options.mode == 'dev':
options.dirs = {
# Built files are stored here, in a subdir. named for the build version.
'www_dir_base': archive_utils.Config.www_dir_base + 'snapshots',
# Symbols are stored here, in a subdirectory named for the build
# version.
'symbol_dir_base': archive_utils.Config.www_dir_base + 'snapshots',
}
else:
option_parser.error('Invalid options mode %s' % options.mode)
if options.build_number is not None:
s = StagerByBuildNumber(options)
else:
s = StagerByChromiumRevision(options)
return s.ArchiveBuild()
if '__main__' == __name__:
sys.exit(main())