def __init__(self, buck_bin_dir, buck_project, buck_reporter): self.buck_dir = platform_path(os.path.dirname(buck_bin_dir)) super(BuckRepo, self).__init__(buck_project, buck_reporter) dot_git = os.path.join(self.buck_dir, ".git") self.is_git = (os.path.exists(dot_git) and os.path.isdir(dot_git) and which("git") and sys.platform != "cygwin") self._is_buck_repo_dirty_override = os.environ.get( "BUCK_REPOSITORY_DIRTY") if not self._fake_buck_version: # self._fake_buck_version has been set previously through BuckTool when the environment # variable BUCK_FAKE_VERSION is set. # If the environement variable is not set, we'll use the content of .fakebuckversion # at the root of the repository if it exists. fake_buck_version_file_path = os.path.join(self.buck_dir, ".fakebuckversion") if os.path.exists(fake_buck_version_file_path): with open( fake_buck_version_file_path) as fake_buck_version_file: self._fake_buck_version = fake_buck_version_file.read( ).strip() logging.info( "Using fake buck version (via .fakebuckversion): {}". format(self._fake_buck_version))
def test_java_home_for_wrong_version_ignored(self): os.environ["JAVA_HOME"] = ( "/Library/Java/JavaVirtualMachines/jdk-" + str(JAVA_VERSION_THAT_OBVIOUSLY_CANT_EXIST_LOCALLY + 1) + ".jdk/Contents/Home") self.assertEquals( get_java_path( JAVA_VERSION_THAT_OBVIOUSLY_CANT_EXIST_LOCALLY).lower(), which("java").lower(), )
def setup_watchman_watch(): with Tracing("BuckTool._setup_watchman_watch"): if not which("watchman"): message = textwrap.dedent("""\ Watchman not found, please install when using buckd. See https://github.com/facebook/watchman for details.""") if sys.platform == "darwin": message += "\n(brew install watchman on OS X)" # Bail if watchman isn't installed as we know java's # FileSystemWatcher will take too long to process events. raise BuckToolException(message) logging.debug("Using watchman.")
def is_vcs(dirpath): # type: (str) -> bool dot_hg = os.path.join(dirpath, ".hg") if which("hg") and sys.platform != "cygwin": if os.path.exists(dot_hg) and os.path.isdir(dot_hg): return True try: with open(os.devnull, "w") as devnull: output = check_output(["hg", "root"], cwd=dirpath, stderr=devnull).decode("utf-8") return os.path.abspath(output.strip()) == os.path.abspath(dirpath) except CalledProcessError: pass return False
def is_vcs(dirpath): # type: (str) -> bool dot_git = os.path.join(dirpath, ".git") if which("git") and sys.platform != "cygwin": if os.path.exists(dot_git) and os.path.isdir(dot_git): return True try: with open(os.devnull, "w") as devnull: output = check_output( ["git", "rev-parse", "--is-inside-work-tree"], cwd=dirpath, stderr=devnull, ).decode("utf-8") return output.strip() == "true" except CalledProcessError: pass return False
def get_java_path(required_java_version): java_home_path = os.getenv("JAVA_HOME") if java_home_path: # Though we try to respect JAVA_HOME, if the path looks like the wrong version of Java, try # to use a known location of the JDK for the right version instead. suspected_java_version = _get_suspected_java_version_from_java_path( java_home_path) if suspected_java_version and suspected_java_version != required_java_version: message = ( 'Warning: JAVA_HOME is set to "{}", which looks like a Java {} path, ' + "but Buck requires Java {}.").format(java_home_path, suspected_java_version, required_java_version) if os.getenv("BUCK_RESPECT_JAVA_HOME") != "1": message += " Ignoring JAVA_HOME. Set BUCK_RESPECT_JAVA_HOME to 1 to disable this behavior." java_home_path = None logging.warning(message) if java_home_path is None: # Default to a known location of the JDK for the right version of Java, regardless of what # version of Java is on the PATH. java_base_path = _get_known_java_path_for_version( required_java_version) java_path = None if java_base_path: java_path = _get_java_exec(java_base_path) if not os.path.isfile(java_path): java_path = None if not java_path: java_path = which("java") if java_path is None: raise BuckToolException("Could not find Java executable. \ Make sure it is on PATH or JAVA_HOME is set.") else: java_path = _get_java_exec(java_home_path) if not os.path.isfile(java_path): message = textwrap.dedent(""" Could not find Java executable under JAVA_HOME at: '{}'. Please make sure your JAVA_HOME environment variable is set correctly. Then restart buck (buck kill) and try again. """).format(java_path) raise BuckToolException(message) return java_path
def launch_buck(self, build_id, client_cwd, java_path, argv): with Tracing("BuckTool.launch_buck"): with JvmCrashLogger(self, self._buck_project.root): self._reporter.build_id = build_id try: repository = self._get_repository() self._reporter.repository = repository except Exception as e: # _get_repository() is only for reporting, # so skip on error logging.warning("Failed to get repo name: " + str(e)) if (self._command_line.command == "clean" and not self._command_line.is_help()): self.kill_buckd() buck_version_uid = self._get_buck_version_uid() self._reporter.buck_version = buck_version_uid if self._command_line.is_version(): print("buck version {}".format(buck_version_uid)) return ExitCodeCallable(ExitCode.SUCCESS) use_buckd = self._use_buckd if not use_buckd: logging.warning("Not using buckd because NO_BUCKD is set.") self._reporter.no_buckd_reason = "explicit" if use_buckd and self._command_line.is_help(): use_buckd = False self._reporter.no_buckd_reason = "help" if use_buckd: has_watchman = bool(which("watchman")) if not has_watchman: use_buckd = False self._reporter.no_buckd_reason = "watchman" logging.warning( "Not using buckd because watchman isn't installed." ) if use_buckd: with exclusive_lock( self._buck_project.get_section_lock_path( "buckd_start_stop"), wait=True, ): need_start = True running_version = self._buck_project.get_running_buckd_version( ) running_jvm_args = ( self._buck_project.get_running_buckd_jvm_args()) jvm_args = self._get_java_args(buck_version_uid) if running_version is None: logging.info("Starting new Buck daemon...") elif running_version != buck_version_uid: logging.info( "Restarting Buck daemon because Buck version has " "changed...") elif not self._is_buckd_running(): logging.info( "Unable to connect to Buck daemon, restarting it..." ) elif jvm_args != running_jvm_args: logging.info( "Restarting Buck daemon because JVM args have " "changed...") else: need_start = False if need_start: self.kill_buckd() if not self.launch_buckd( java_path, jvm_args, buck_version_uid=buck_version_uid): use_buckd = False self._reporter.no_buckd_reason = "daemon_failure" logging.warning( "Not using buckd because daemon failed to start." ) env = self._environ_for_buck() env["BUCK_BUILD_ID"] = build_id env["BUCK_CLIENT_PWD"] = client_cwd self._reporter.is_buckd = use_buckd run_fn = (self._run_with_nailgun if use_buckd else self._run_without_nailgun) self._unpack_modules() exit_code_callable = self._execute_command_and_maybe_run_target( run_fn, java_path, env, argv) # Most shells return process termination with signal as # 128 + N, where N is the signal. However Python's subprocess # call returns them as negative numbers. Buck binary protocol # uses shell's convention, so convert if exit_code_callable.exit_code < 0: exit_code_callable.exit_code = 128 + ( -1 * exit_code_callable.exit_code) return exit_code_callable
def test_without_java_home(self): self.assertEquals( get_java_path( JAVA_VERSION_THAT_OBVIOUSLY_CANT_EXIST_LOCALLY).lower(), which("java").lower(), )