| # Copyright 2015 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. |
| |
| """Library module for building go binaries used by build_mojom_tool and |
| build_generators. |
| """ |
| |
| import argparse |
| import imp |
| import os |
| import shutil |
| import subprocess |
| import sys |
| |
| |
| class GoBinaryBuilder(object): |
| _TARGET_ARCHITECTURES = [ |
| ('darwin', 'amd64'), |
| ('linux', 'amd64'), |
| ] |
| |
| def __init__(self, |
| target_dir, |
| binary_name, |
| src_path, |
| src_root=None, |
| go_tool=None, |
| go_root=None, |
| out_dir=None, |
| upload=False, |
| friendly_name=None, |
| quiet=False, |
| keep_going=False): |
| """Builds a go binary building object. |
| |
| Args: |
| target_dir: Relative path from the architecture directory to the |
| directory which contains the sha1 file. |
| binary_name: File name for the binary to be built. |
| src_path: Path from src_root to the directory which contains the main |
| package for the binary to be built. |
| src_root: Path to the root of the source tree. (If None, the path of the |
| directory 3 levels above the one containing this script is used.) |
| go_tool: Path to the go tool. |
| (If None, uses {src_root}/third_party/go/tool/linux_amd64/bin/go) |
| go_root: Path to the root of the go installation. |
| (If None, uses the directory containing the go tool.) |
| out_dir: Path to the directory in which the built binary should be placed. |
| (If None, uses the current working directory.) |
| upload: If True, get the path to the depot tools as those are needed to |
| upload only. If False, the upload method will fail. |
| quiet: If True, do not print any messages on success. |
| keep_going: If True, move on to the next step when experiencing a failure. |
| """ |
| self._target_dir = target_dir |
| self._binary_name = binary_name |
| self._src_path = src_path |
| if src_root: |
| self._src_root = os.path.abspath(src_root) |
| else: |
| self._src_root = os.path.abspath( |
| os.path.join(os.path.dirname(__file__), *([os.pardir] * 2))) |
| assert os.path.exists(self._src_root) |
| |
| if go_tool: |
| self._go_tool = os.path.abspath(go_tool) |
| else: |
| self._go_tool = os.path.join(self._src_root, |
| 'third_party', 'go', 'tool', 'linux_amd64', 'bin', 'go') |
| assert os.path.exists(self._go_tool) |
| |
| if go_root: |
| self._go_root = os.path.abspath(go_root) |
| else: |
| self._go_root = os.path.dirname(os.path.dirname(self._go_tool)) |
| assert os.path.exists(self._go_root) |
| |
| if not out_dir: |
| out_dir = os.getcwd() |
| self._out_dir = os.path.abspath(out_dir) |
| |
| self._depot_tools_path = None |
| if upload: |
| self._depot_tools_path = self._get_depot_tools_path(self._src_root) |
| |
| self._quiet = quiet |
| self._keep_going = keep_going |
| |
| self._friendly_name = friendly_name |
| if self._friendly_name is None: |
| self._friendly_name = binary_name |
| |
| def build_and_upload(self): |
| """Builds and then uploads the binary for every target architecture. |
| |
| Returns: |
| 0 if everything went well. The return code of the last command to fail |
| otherwise. |
| """ |
| final_result = 0 |
| |
| # First we build the binary for every architecture. |
| result = self.build() |
| if result != 0: |
| final_result = result |
| if not self._keep_going: |
| return result |
| |
| # Then we upload the binary for every architecture. |
| result = self.upload() |
| if result != 0: |
| final_result = result |
| if not self._keep_going: |
| return result |
| |
| return final_result |
| |
| def build(self): |
| """Builds the binary for every target architectures. |
| |
| Returns: |
| 0 if everything went well. The return code of the last command to fail |
| otherwise. |
| """ |
| final_result = 0 |
| for target_os, target_arch in self._TARGET_ARCHITECTURES: |
| result = self._build_for_arch(target_os, target_arch) |
| if result != 0: |
| final_result = result |
| if not self._keep_going: |
| return result |
| |
| return final_result |
| |
| def upload(self): |
| """Uploads the binary that was just created for every target arch. |
| |
| Returns: |
| 0 if everything went well. The return code of the last command to fail |
| otherwise. |
| """ |
| final_result = 0 |
| for target_os, target_arch in self._TARGET_ARCHITECTURES: |
| result = self._upload_for_arch(target_os, target_arch) |
| if result != 0: |
| final_result = result |
| if not self._keep_going: |
| return result |
| return final_result |
| |
| def _upload_for_arch(self, target_os, target_arch): |
| """Uploads the binary that was just created for the given target. |
| |
| upload must have been set to True when creating this class. |
| |
| Args: |
| target_os: Any value valid for GOOS. |
| target_arch: Any value valid for GOARCH. |
| |
| Returns: |
| 0 if everything went well, something else otherwise. |
| """ |
| assert self._depot_tools_path |
| upload_result = self._upload_binary(target_os, target_arch) |
| if upload_result != 0: |
| return upload_result |
| |
| # Copy the generated sha1 file to the stamp_file location. |
| target_dir = os.path.join( |
| self._get_dir_name_for_arch(target_os, target_arch), |
| self._target_dir) |
| sha1_file = '%s.sha1' % self._get_output_path(target_os, target_arch) |
| assert os.path.exists(sha1_file) |
| stamp_file = os.path.join(self._src_root, 'mojo', 'public', 'tools', |
| 'bindings', 'mojom_tool', 'bin', target_dir, |
| '%s.sha1' % self._binary_name) |
| shutil.move(sha1_file, stamp_file) |
| self._info_print( |
| "Wrote stamp file %s. You probably want to commit this." % stamp_file) |
| |
| return 0 |
| |
| def _build_for_arch(self, target_os, target_arch): |
| """Builds the mojom parser for target_os and target_arch. |
| |
| Args: |
| target_os: Any value valid for GOOS. |
| target_arch: Any value valid for GOARCH. |
| |
| Returns: |
| The go tool's return value. |
| """ |
| out_path = self._get_output_path(target_os, target_arch) |
| |
| environ = { |
| 'GOROOT': self._go_root, |
| 'GOPATH': os.path.dirname(self._src_root), |
| 'GOOS': target_os, |
| 'GOARCH': target_arch, |
| } |
| |
| save_cwd = os.getcwd() |
| os.chdir(os.path.join(self._src_root, self._src_path)) |
| self._info_print( |
| "Building the Mojom parser for %s %s..." % (target_os, target_arch)) |
| result = subprocess.call( |
| [self._go_tool, 'build', '-o', out_path] , env=environ) |
| if result == 0: |
| self._info_print("Success! Built %s" % out_path) |
| else: |
| print >> sys.stderr, "Failure building Mojom parser for %s %s!" % ( |
| target_os, target_arch) |
| |
| os.chdir(save_cwd) |
| |
| return result |
| |
| def _upload_binary(self, target_os, target_arch): |
| """Computes the sha1 digest of the contents of the specified binary, then |
| uploads the contents of the file at that path to the Google Cloud Storage |
| bucket "mojo" using the filename "mojom_tool/$%target/$sha1." $target |
| is computed based upon the target_os and target_arch. A file whose name is |
| the name of the binary with .sha1 appended is created containing the sha1. |
| |
| This method will only work if self._depot_tools_path has been set. |
| """ |
| assert self._depot_tools_path |
| upload_script = os.path.abspath(os.path.join(self._depot_tools_path, |
| "upload_to_google_storage.py")) |
| out_path = self._get_output_path(target_os, target_arch) |
| assert os.path.exists(out_path) |
| |
| |
| cloud_path = 'mojo/mojom_parser/%s' % self._get_dir_name_for_arch( |
| target_os, target_arch) |
| if self._target_dir: |
| cloud_path = '%s/%s' % (cloud_path, self._target_dir) |
| |
| upload_cmd = ['python', upload_script, out_path, '-b', cloud_path] |
| |
| stdout = None |
| if self._quiet: |
| stdout = open(os.devnull, 'w') |
| self._info_print( |
| "Uploading %s (%s,%s) to GCS..." % |
| (self._friendly_name, target_os, target_arch)) |
| return subprocess.call(upload_cmd, stdout=stdout) |
| |
| def _get_dir_name_for_arch(self, target_os, target_arch): |
| dir_names = { |
| ('darwin', 'amd64'): 'mac64', |
| ('linux', 'amd64'): 'linux64', |
| } |
| return dir_names[(target_os, target_arch)] |
| |
| def _get_output_path(self, target_os, target_arch): |
| return os.path.join( |
| self._out_dir, '%s_%s_%s' % (self._binary_name, target_os, target_arch)) |
| |
| def _get_depot_tools_path(self, src_root): |
| name = 'find_depot_tools' |
| find_depot_tools = imp.load_source(name, |
| os.path.join(src_root, 'tools', name + '.py')) |
| return find_depot_tools.add_depot_tools_to_path() |
| |
| def _info_print(self, message): |
| if self._quiet: |
| return |
| print message |
| |
| |
| def get_arg_parser(description): |
| """Returns an ArgumentParser instance with the provided description and with |
| required arguments already added. |
| """ |
| parser = argparse.ArgumentParser(description=description) |
| parser.add_argument('--src-root', dest='src_root', action='store', |
| help='Path to the source tree. (optional)') |
| parser.add_argument('--go-tool', dest='go_tool', action='store', |
| help='Path to the go tool. (optional)') |
| parser.add_argument('--go-root', dest='go_root', action='store', |
| help='Path to the root of the go installation. ' |
| '(optional)') |
| parser.add_argument('--out-dir', dest='out_dir', action='store', |
| help='Directory in which to place the built binary. ' |
| 'Defaults to the current working directory. ' |
| '(optional)') |
| parser.add_argument('--upload', dest='upload', action='store_true', |
| default=False, |
| help='Upload the built binaries to Google Cloud Storage ' |
| 'and update the corresponding hash files locally.') |
| parser.add_argument('--keep-going', dest='keep_going', action='store_true', |
| default=False, |
| help='Instead of stopping when encountering a failure ' |
| 'move on to the next step.') |
| parser.add_argument('--quiet', dest='quiet', action='store_true', |
| default=False, |
| help='Do not output anything on success.') |
| return parser |
| |
| |
| def get_builder(args, target_dir, binary_name, src_path, friendly_name=None): |
| """Return a GoBinaryBuilder object.""" |
| return GoBinaryBuilder( |
| target_dir=target_dir, |
| binary_name=binary_name, |
| src_path=src_path, |
| src_root=args.src_root, |
| go_tool=args.go_tool, |
| go_root=args.go_root, |
| out_dir=args.out_dir, |
| upload=args.upload, |
| quiet=args.quiet, |
| keep_going=args.keep_going, |
| friendly_name=friendly_name) |
| |
