build/bazel/scripts/prepare-fuchsia-checkout.py - fuchsia - Git at Google

 #!/usr/bin/env python3
 # Copyright 2022 The Fuchsia Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """Prepare a Fuchsia checkout for 'fx bazel'. This is a temporary measure
 until all requirements are properly managed with 'jiri'."""

 import argparse
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import urllib.request
 import xml.etree.ElementTree as ET

 _SCRIPT_DIR = os.path.dirname(__file__)


 def get_host_platform() -> str:
     """Return host platform name, following Fuchsia conventions."""
     if sys.platform == "linux":
         return "linux"
     elif sys.platform == "darwin":
         return "mac"
     else:
         return os.uname().sysname


 def get_host_arch() -> str:
     """Return host CPU architecture, following Fuchsia conventions."""
     host_arch = os.uname().machine
     if host_arch == "x86_64":
         return "x64"
     elif host_arch.startswith(("armv8", "aarch64")):
         return "arm64"
     else:
         return host_arch


 def get_host_tag():
     """Return host tag, following Fuchsia conventions."""
     return "%s-%s" % (get_host_platform(), get_host_arch())


 def write_file(path, content):
     with open(path, "w") as f:
         f.write(content)


 def clone_git_branch(git_url, git_branch, dst_dir):
     subprocess.check_call(
         ["git", "clone", "--branch", git_branch, "--depth=1", git_url, dst_dir],
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
     )


 def clone_git_commit(git_url, git_commit, dst_dir):
     def git_cmd(args):
         subprocess.check_call(
             ["git", "-C", dst_dir] + args,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )

     git_cmd(["init"])
     git_cmd(["remote", "add", "origin", git_url])
     git_cmd(["fetch", "origin", git_commit])
     git_cmd(["reset", "--hard", "FETCH_HEAD"])


 def get_bazel_download_url(version: str) -> str:
     """Return Bazel download URL for a specific version and the current host platform."""
     if sys.platform == "linux":
         host_os = "linux"
     elif sys.platform == "darwin":
         host_os = "darwin"
     elif sys.platform in ("win32", "cygwin"):
         host_os = "windows"
     else:
         host_os = os.uname().sysname

     host_cpu = os.uname().machine
     if host_cpu.startswith(("armv8", "aarch64")):
         host_cpu = "arm64"

     ext = ".exe" if host_os == "windows" else ""

     return f"https://github.com/bazelbuild/bazel/releases/download/{version}/bazel-{version}-{host_os}-{host_cpu}{ext}"


 def get_bazel_version(bazel_launcher):
     """Return version of a given Bazel binary."""
     output = subprocess.check_output(
         [bazel_launcher, "version"], stderr=subprocess.DEVNULL, text=True
     )
     version_prefix = "Build label: "
     for line in output.splitlines():
         if line.startswith(version_prefix):
             return line[len(version_prefix) :].strip()
     return None


 def ignore_log(message):
     pass


 _FALLBACK_BAZEL_VERSION = "5.3.0"


 def get_jiri_bazel_version(fuchsia_dir, log=ignore_log):
     # The location of the file that contains the Jiri Bazel package definition
     prebuilts_file = os.path.join(
         fuchsia_dir, "integration", "fuchsia", "prebuilts"
     )
     if not os.path.exists(prebuilts_file):
         log(
             "Could not find Jiri file defining Bazel version at: %s (using fallback version %s)"
             % (prebuilts_file, _FALLBACK_BAZEL_VERSION)
         )
         return _FALLBACK_BAZEL_VERSION

     version = None
     prebuilts = ET.parse(prebuilts_file)
     for package in prebuilts.findall("packages/package"):
         package_name = package.get("name")
         if package_name == "fuchsia/third_party/bazel/${platform}":
             version = package.get("version")
             break

     if not version:
         log(
             "Could not find Bazel package in: %s (using fallback version %s)"
             % (prebuilts_file, _FALLBACK_BAZEL_VERSION)
         )
         return _FALLBACK_BAZEL_VERSION

     # The package version has a .<patch> sufix which corresponds to
     # the LUCI recipe patch number, so remove it.
     pos = version.rfind(".")
     if pos > 0:
         version = version[:pos]

     version_prefix = "version:2@"
     if not version.startswith(version_prefix):
         log(
             "Unsupported Bazel version tag (%s), using fallback %s"
             % (version, _FALLBACK_BAZEL_VERSION)
         )
         return _FALLBACK_BAZEL_VERSION

     return version[len(version_prefix) :]


 class InstallDirectory(object):
     def __init__(self, path):
         self._tmp_dir = path + ".tmp"
         self._dst_dir = path
         self._old_dir = path + ".old"

     @property
     def path(self):
         return self._tmp_dir

     @property
     def final_path(self):
         return self._dst_dir

     def __enter__(self):
         if os.path.exists(self._tmp_dir):
             shutil.rmtree(self._tmp_dir)
         os.makedirs(self._tmp_dir)
         return self

     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_type is not None:
             # An exception occurred, cleanup temp dir.
             shutil.rmtree(self._tmp_dir)
         else:
             if os.path.exists(self._old_dir):
                 shutil.rmtree(self._old_dir)
             os.rename(self._dst_dir, self._old_dir)
             os.rename(self._tmp_dir, self._dst_dir)
         return False


 def main():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
         "--fuchsia-dir", help="Path to Fuchsia checkout directory."
     )
     parser.add_argument(
         "--bazel-version", help="Set Bazel binary version to use."
     )
     parser.add_argument(
         "--quiet", action="store_true", help="Disable verbose output."
     )

     args = parser.parse_args()

     def log(message):
         if not args.quiet:
             print(message, flush=True)

     if not args.fuchsia_dir:
         # Assume this script is under build/bazel/scripts/
         args.fuchsia_dir = os.path.abspath(
             os.path.join(_SCRIPT_DIR, "..", "..", "..")
         )
         log("Found Fuchsia dir: %s" % args.fuchsia_dir)

     if not args.bazel_version:
         args.bazel_version = get_jiri_bazel_version(args.fuchsia_dir, log=log)
         if not args.bazel_version:
             return 1
         log("Using default Bazel version: " + args.bazel_version)

     # Compare the available Bazel version with the one we need.
     bazel_install_path = os.path.join(
         args.fuchsia_dir, "prebuilt", "third_party", "bazel", get_host_tag()
     )
     bazel_launcher = os.path.join(bazel_install_path, "bazel")
     bazel_update = not os.path.exists(bazel_launcher)
     if not bazel_update:
         current_version = get_bazel_version(bazel_launcher)
         if current_version != args.bazel_version:
             log(
                 "Found installed Bazel version %s, updating to %s"
                 % (current_version, args.bazel_version)
             )
             bazel_update = True

     if bazel_update:
         with tempfile.TemporaryDirectory() as tmpdirname:
             bazel_bin = os.path.join(tmpdirname, "bazel-" + args.bazel_version)
             url = get_bazel_download_url(args.bazel_version)
             log("Downloading %s" % url)
             urllib.request.urlretrieve(url, bazel_bin)
             os.chmod(bazel_bin, 0o750)

             log("Generating Bazel install at: %s" % bazel_install_path)
             with InstallDirectory(bazel_install_path) as install:
                 subprocess.check_call(
                     [
                         sys.executable,
                         "-S",
                         os.path.join(_SCRIPT_DIR, "generate-bazel-install.py"),
                         "--bazel",
                         bazel_bin,
                         "--install-dir",
                         install.path,
                         "--force",
                     ],
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.PIPE,
                 )

     return 0


 if __name__ == "__main__":
     sys.exit(main())
	#!/usr/bin/env python3
	# Copyright 2022 The Fuchsia Authors. All rights reserved.
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.
	"""Prepare a Fuchsia checkout for 'fx bazel'. This is a temporary measure
	until all requirements are properly managed with 'jiri'."""

	import argparse
	import os
	import shutil
	import subprocess
	import sys
	import tempfile
	import urllib.request
	import xml.etree.ElementTree as ET

	_SCRIPT_DIR = os.path.dirname(__file__)


	def get_host_platform() -> str:
	"""Return host platform name, following Fuchsia conventions."""
	if sys.platform == "linux":
	return "linux"
	elif sys.platform == "darwin":
	return "mac"
	else:
	return os.uname().sysname


	def get_host_arch() -> str:
	"""Return host CPU architecture, following Fuchsia conventions."""
	host_arch = os.uname().machine
	if host_arch == "x86_64":
	return "x64"
	elif host_arch.startswith(("armv8", "aarch64")):
	return "arm64"
	else:
	return host_arch


	def get_host_tag():
	"""Return host tag, following Fuchsia conventions."""
	return "%s-%s" % (get_host_platform(), get_host_arch())


	def write_file(path, content):
	with open(path, "w") as f:
	f.write(content)


	def clone_git_branch(git_url, git_branch, dst_dir):
	subprocess.check_call(
	["git", "clone", "--branch", git_branch, "--depth=1", git_url, dst_dir],
	stdout=subprocess.PIPE,
	stderr=subprocess.PIPE,
	)


	def clone_git_commit(git_url, git_commit, dst_dir):
	def git_cmd(args):
	subprocess.check_call(
	["git", "-C", dst_dir] + args,
	stdout=subprocess.PIPE,
	stderr=subprocess.PIPE,
	)

	git_cmd(["init"])
	git_cmd(["remote", "add", "origin", git_url])
	git_cmd(["fetch", "origin", git_commit])
	git_cmd(["reset", "--hard", "FETCH_HEAD"])


	def get_bazel_download_url(version: str) -> str:
	"""Return Bazel download URL for a specific version and the current host platform."""
	if sys.platform == "linux":
	host_os = "linux"
	elif sys.platform == "darwin":
	host_os = "darwin"
	elif sys.platform in ("win32", "cygwin"):
	host_os = "windows"
	else:
	host_os = os.uname().sysname

	host_cpu = os.uname().machine
	if host_cpu.startswith(("armv8", "aarch64")):
	host_cpu = "arm64"

	ext = ".exe" if host_os == "windows" else ""

	return f"https://github.com/bazelbuild/bazel/releases/download/{version}/bazel-{version}-{host_os}-{host_cpu}{ext}"


	def get_bazel_version(bazel_launcher):
	"""Return version of a given Bazel binary."""
	output = subprocess.check_output(
	[bazel_launcher, "version"], stderr=subprocess.DEVNULL, text=True
	)
	version_prefix = "Build label: "
	for line in output.splitlines():
	if line.startswith(version_prefix):
	return line[len(version_prefix) :].strip()
	return None


	def ignore_log(message):
	pass


	_FALLBACK_BAZEL_VERSION = "5.3.0"


	def get_jiri_bazel_version(fuchsia_dir, log=ignore_log):
	# The location of the file that contains the Jiri Bazel package definition
	prebuilts_file = os.path.join(
	fuchsia_dir, "integration", "fuchsia", "prebuilts"
	)
	if not os.path.exists(prebuilts_file):
	log(
	"Could not find Jiri file defining Bazel version at: %s (using fallback version %s)"
	% (prebuilts_file, _FALLBACK_BAZEL_VERSION)
	)
	return _FALLBACK_BAZEL_VERSION

	version = None
	prebuilts = ET.parse(prebuilts_file)
	for package in prebuilts.findall("packages/package"):
	package_name = package.get("name")
	if package_name == "fuchsia/third_party/bazel/${platform}":
	version = package.get("version")
	break

	if not version:
	log(
	"Could not find Bazel package in: %s (using fallback version %s)"
	% (prebuilts_file, _FALLBACK_BAZEL_VERSION)
	)
	return _FALLBACK_BAZEL_VERSION

	# The package version has a .<patch> sufix which corresponds to
	# the LUCI recipe patch number, so remove it.
	pos = version.rfind(".")
	if pos > 0:
	version = version[:pos]

	version_prefix = "version:2@"
	if not version.startswith(version_prefix):
	log(
	"Unsupported Bazel version tag (%s), using fallback %s"
	% (version, _FALLBACK_BAZEL_VERSION)
	)
	return _FALLBACK_BAZEL_VERSION

	return version[len(version_prefix) :]


	class InstallDirectory(object):
	def __init__(self, path):
	self._tmp_dir = path + ".tmp"
	self._dst_dir = path
	self._old_dir = path + ".old"

	@property
	def path(self):
	return self._tmp_dir

	@property
	def final_path(self):
	return self._dst_dir

	def __enter__(self):
	if os.path.exists(self._tmp_dir):
	shutil.rmtree(self._tmp_dir)
	os.makedirs(self._tmp_dir)
	return self

	def __exit__(self, exc_type, exc_val, exc_tb):
	if exc_type is not None:
	# An exception occurred, cleanup temp dir.
	shutil.rmtree(self._tmp_dir)
	else:
	if os.path.exists(self._old_dir):
	shutil.rmtree(self._old_dir)
	os.rename(self._dst_dir, self._old_dir)
	os.rename(self._tmp_dir, self._dst_dir)
	return False


	def main():
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument(
	"--fuchsia-dir", help="Path to Fuchsia checkout directory."
	)
	parser.add_argument(
	"--bazel-version", help="Set Bazel binary version to use."
	)
	parser.add_argument(
	"--quiet", action="store_true", help="Disable verbose output."
	)

	args = parser.parse_args()

	def log(message):
	if not args.quiet:
	print(message, flush=True)

	if not args.fuchsia_dir:
	# Assume this script is under build/bazel/scripts/
	args.fuchsia_dir = os.path.abspath(
	os.path.join(_SCRIPT_DIR, "..", "..", "..")
	)
	log("Found Fuchsia dir: %s" % args.fuchsia_dir)

	if not args.bazel_version:
	args.bazel_version = get_jiri_bazel_version(args.fuchsia_dir, log=log)
	if not args.bazel_version:
	return 1
	log("Using default Bazel version: " + args.bazel_version)

	# Compare the available Bazel version with the one we need.
	bazel_install_path = os.path.join(
	args.fuchsia_dir, "prebuilt", "third_party", "bazel", get_host_tag()
	)
	bazel_launcher = os.path.join(bazel_install_path, "bazel")
	bazel_update = not os.path.exists(bazel_launcher)
	if not bazel_update:
	current_version = get_bazel_version(bazel_launcher)
	if current_version != args.bazel_version:
	log(
	"Found installed Bazel version %s, updating to %s"
	% (current_version, args.bazel_version)
	)
	bazel_update = True

	if bazel_update:
	with tempfile.TemporaryDirectory() as tmpdirname:
	bazel_bin = os.path.join(tmpdirname, "bazel-" + args.bazel_version)
	url = get_bazel_download_url(args.bazel_version)
	log("Downloading %s" % url)
	urllib.request.urlretrieve(url, bazel_bin)
	os.chmod(bazel_bin, 0o750)

	log("Generating Bazel install at: %s" % bazel_install_path)
	with InstallDirectory(bazel_install_path) as install:
	subprocess.check_call(
	[
	sys.executable,
	"-S",
	os.path.join(_SCRIPT_DIR, "generate-bazel-install.py"),
	"--bazel",
	bazel_bin,
	"--install-dir",
	install.path,
	"--force",
	],
	stdout=subprocess.DEVNULL,
	stderr=subprocess.PIPE,
	)

	return 0


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