You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
221 lines
7.4 KiB
221 lines
7.4 KiB
# Copyright (C) 2018 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
"""Downloads prebuilt from the build server."""
|
|
|
|
import argparse
|
|
import logging
|
|
import os
|
|
import os.path
|
|
import shutil
|
|
import stat
|
|
import sys
|
|
import textwrap
|
|
|
|
|
|
class InstallEntry(object):
|
|
def __init__(self, target, name, install_path,
|
|
need_strip=False, need_exec=False, need_unzip=False,
|
|
install_unzipped=False):
|
|
self.target = target
|
|
self.name = name
|
|
self.install_path = install_path
|
|
self.need_strip = need_strip
|
|
self.need_exec = need_exec
|
|
|
|
# Installs a zip file, and also unzips it into the same directory. The
|
|
# unzipped contents are not automatically installed.
|
|
self.need_unzip = need_unzip
|
|
|
|
# Install the unzipped contents of a zip file into install_path, but not
|
|
# the file itself. All old content in install_path is removed first.
|
|
self.install_unzipped = install_unzipped
|
|
|
|
def logger():
|
|
"""Returns the main logger for this module."""
|
|
return logging.getLogger(__name__)
|
|
|
|
|
|
def check_call(cmd):
|
|
"""Proxy for subprocess.check_call with logging."""
|
|
import subprocess
|
|
logger().debug('check_call `%s`', ' '.join(cmd))
|
|
subprocess.check_call(cmd)
|
|
|
|
|
|
def fetch_artifact(branch, build, target, pattern):
|
|
"""Fetches artifact from the build server."""
|
|
logger().info('Fetching %s from %s %s (artifacts matching %s)', build,
|
|
target, branch, pattern)
|
|
if target.startswith('local:'):
|
|
shutil.copyfile(target[6:], pattern)
|
|
return
|
|
fetch_artifact_path = '/google/data/ro/projects/android/fetch_artifact'
|
|
cmd = [fetch_artifact_path, '--branch', branch, '--target', target,
|
|
'--bid', build, pattern]
|
|
check_call(cmd)
|
|
|
|
|
|
def copy_artifact(local_dist, target, name):
|
|
"""Copies artifact from a local dist directory."""
|
|
source_path = (target[6:] if target.startswith('local:')
|
|
else os.path.join(local_dist, name))
|
|
logger().info('Copying from %s', source_path)
|
|
shutil.copyfile(source_path, os.path.basename(name))
|
|
|
|
|
|
def start_branch(build):
|
|
"""Creates a new branch in the project."""
|
|
branch_name = 'update-' + (build or 'latest')
|
|
logger().info('Creating branch %s', branch_name)
|
|
check_call(['repo', 'start', branch_name, '.'])
|
|
|
|
|
|
def commit(prebuilts, branch, build, add_paths, commit_message_note):
|
|
"""Commits the new prebuilts."""
|
|
logger().info('Making commit')
|
|
check_call(['git', 'add'] + add_paths)
|
|
if build:
|
|
message = textwrap.dedent("""\
|
|
Update {prebuilts} prebuilts to build {build}.
|
|
|
|
Taken from branch {branch}.""").format(
|
|
prebuilts=prebuilts, branch=branch, build=build)
|
|
else:
|
|
message = (
|
|
'DO NOT SUBMIT: Update {prebuilts} prebuilts from local build.'
|
|
.format(prebuilts=prebuilts))
|
|
if commit_message_note:
|
|
message += "\n\n" + commit_message_note
|
|
check_call(['git', 'commit', '-m', message])
|
|
|
|
|
|
def list_installed_files(install_list, extracted_list):
|
|
"""List all prebuilts in current directory."""
|
|
result = []
|
|
for entry in install_list:
|
|
result += [entry.install_path]
|
|
for entry in extracted_list:
|
|
result += [entry.install_path]
|
|
return result
|
|
|
|
|
|
def remove_old_files(install_list, extracted_list):
|
|
"""Removes the old files."""
|
|
old_files = list_installed_files(install_list, extracted_list)
|
|
if not old_files:
|
|
return
|
|
logger().info('Removing old files %s', old_files)
|
|
check_call(['git', 'rm', '-qrf', '--ignore-unmatch'] + old_files)
|
|
|
|
# Need to check again because git won't remove directories if they have
|
|
# non-git files in them.
|
|
check_call(['rm', '-rf'] + old_files)
|
|
|
|
|
|
def install_new_files(branch, build, local_dist, install_list, extracted_list):
|
|
"""Installs the new release."""
|
|
for entry in install_list:
|
|
install_entry(branch, build, local_dist, entry)
|
|
for entry in extracted_list:
|
|
if entry.need_strip:
|
|
check_call(['strip', entry.name])
|
|
|
|
|
|
def install_entry(branch, build, local_dist, entry):
|
|
"""Installs one file specified by entry."""
|
|
target = entry.target
|
|
name = entry.name
|
|
install_path = entry.install_path
|
|
need_strip = entry.need_strip
|
|
need_exec = entry.need_exec
|
|
need_unzip = entry.need_unzip
|
|
install_unzipped = entry.install_unzipped
|
|
|
|
if build:
|
|
fetch_artifact(branch, build, target, name)
|
|
else:
|
|
copy_artifact(local_dist, target, name)
|
|
if need_strip:
|
|
check_call(['strip', name])
|
|
if need_exec:
|
|
check_call(['chmod', 'a+x', name])
|
|
|
|
if install_unzipped:
|
|
os.makedirs(install_path)
|
|
zip_file = os.path.basename(name)
|
|
unzip(zip_file, install_path)
|
|
check_call(['rm', zip_file])
|
|
else:
|
|
dir = os.path.dirname(install_path)
|
|
if dir and not os.path.isdir(dir):
|
|
os.makedirs(dir)
|
|
shutil.move(os.path.basename(name), install_path)
|
|
if need_unzip:
|
|
unzip(install_path, os.path.dirname(install_path))
|
|
|
|
def unzip(zip_file, unzip_path):
|
|
# Add -DD to not extract timestamps that may confuse the build system.
|
|
check_call(['unzip', '-DD', zip_file, '-d', unzip_path])
|
|
|
|
|
|
def get_args():
|
|
"""Parses and returns command line arguments."""
|
|
parser = argparse.ArgumentParser(
|
|
epilog='Either --build or --local-dist is required.')
|
|
|
|
parser.add_argument(
|
|
'-b', '--branch', default='aosp-master',
|
|
help='Branch to pull build from.')
|
|
parser.add_argument('--build', help='Build number to pull.')
|
|
parser.add_argument('--local-dist',
|
|
help='Take prebuilts from this local dist dir instead of '
|
|
'using fetch_artifact')
|
|
parser.add_argument(
|
|
'--use-current-branch', action='store_true',
|
|
help='Perform the update in the current branch. Do not repo start.')
|
|
parser.add_argument(
|
|
'-v', '--verbose', action='count', default=0,
|
|
help='Increase output verbosity.')
|
|
|
|
args = parser.parse_args()
|
|
if ((not args.build and not args.local_dist) or
|
|
(args.build and args.local_dist)):
|
|
sys.exit(parser.format_help())
|
|
return args
|
|
|
|
|
|
def main(work_dir, prebuilts, install_list, extracted_list, commit_message_note=None):
|
|
"""Program entry point."""
|
|
|
|
args = get_args()
|
|
verbose_map = (logging.WARNING, logging.INFO, logging.DEBUG)
|
|
verbosity = args.verbose
|
|
if verbosity > 2:
|
|
verbosity = 2
|
|
logging.basicConfig(level=verbose_map[verbosity])
|
|
|
|
local_dist = args.local_dist
|
|
if local_dist:
|
|
local_dist = os.path.abspath(local_dist)
|
|
|
|
os.chdir(work_dir)
|
|
|
|
if not args.use_current_branch:
|
|
start_branch(args.build)
|
|
remove_old_files(install_list, extracted_list)
|
|
install_new_files(args.branch, args.build, local_dist, install_list, extracted_list)
|
|
files = list_installed_files(install_list, extracted_list)
|
|
commit(prebuilts, args.branch, args.build, files, commit_message_note)
|