#!/usr/bin/env python
# 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.

"""Build and optionally upload mojom_parser to Google Cloud Storage.

This script is used to build a new version of the mojom_parser binary for both
mac and linux and optionally upload them to Google Cloud Storage based on their
SHA1 digest. It operates in 2 steps:
  1) Invokes the Go compiler to build the mojom parser for all
  target os and architectures.
  2) If the --upload flag is specified, for each of the binaries built:
    i) Computes the sha1 digest of the binary file.
    ii) Uploads the file to Google Cloud Storage using the sha1 as the filename.
    iii) Updates a local file named "mojom_parser.sha1" to contain the sha1
    digest of the file that was uploaded. This allows "gclient sync" to download
    the file.

In order to use this script to upload a new version of the parser, you need:
- depot_tools in your path
- WRITE access to the bucket at
  https://console.developers.google.com/storage/browser/mojo/mojom_parser/.

If you want to hack on the parser and use your locally-built version, from the
Mojo source root directory do:
1) Run this script: mojom/mojom_parser/tools/build_mojom_parser.py
2) Copy the architecture-specific binary to the architecture-specific location:
For example for linux do:
cp mojom_parser_linux_amd64  \
mojo/public/tools/bindings/mojom_parser/bin/linux64/mojom_parser

This script will build for all architectures before it attempts to upload any
binary. If any of the builds fail, the whole script will abort and nothing will
be uploaded. This behavior can be overriden with the --keep-going flag.
"""

import argparse
import imp
import os
import shutil
import subprocess
import sys


class ParserBuilder(object):
  def __init__(self,
      src_root=None,
      go_tool=None,
      go_root=None,
      out_dir=None,
      upload=False,
      quiet=False):
    """Builds a parser building function.

    Args:
      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 parser 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.
    """
    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] * 3)))
    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

  def upload(self, target_os, target_arch):
    """Uploads the mojom parser 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 = self._get_dir_name_for_arch(target_os, target_arch)
    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_parser', 'bin', target_dir, 'mojom_parser.sha1')
    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_parser(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, 'mojom', 'mojom_parser'))
    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_parser/$%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)

    upload_cmd = ['python', upload_script, out_path, '-b', cloud_path]

    stdout = None
    if self._quiet:
      stdout = open(os.devnull, 'w')
    self._info_print(
        "Uploading mojom_parser (%s,%s) to GCS..." % (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,
                        'mojom_parser_%s_%s' % (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 main():
  parser = argparse.ArgumentParser(description="Build the mojom parser.")
  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 parser. '
                           '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.')
  args = parser.parse_args()
  parser_builder = ParserBuilder(
      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)

  targets = [
      ('darwin', 'amd64'),
      ('linux', 'amd64'),
      ]
  final_result = 0
  # First we build the mojom parser for each target.
  for target_os, target_arch in targets:
    result = parser_builder.build_parser(target_os, target_arch)
    if result != 0:
      final_result = result
      if not args.keep_going:
        return result

  # Then we upload each target.
  if args.upload:
    for target_os, target_arch in targets:
      result = parser_builder.upload(target_os, target_arch)
      if result != 0:
        final_result = result
        if not args.keep_going:
          return result

  return final_result


if __name__ == '__main__':
  sys.exit(main())