| // Copyright 2014 The Bazel Authors. All rights reserved. |
| // |
| // 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. |
| #ifndef BAZEL_SRC_MAIN_CPP_STARTUP_OPTIONS_H_ |
| #define BAZEL_SRC_MAIN_CPP_STARTUP_OPTIONS_H_ |
| |
| #if defined(__APPLE__) |
| #include <sys/qos.h> |
| #endif |
| |
| #include <functional> |
| #include <map> |
| #include <string> |
| #include <unordered_map> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
| |
| #include "src/main/cpp/util/exit_code.h" |
| #include "src/main/cpp/util/path.h" |
| |
| namespace blaze { |
| |
| class WorkspaceLayout; |
| |
| // A startup flag tagged with its origin, either an rc file or the empty |
| // string for the ones specified in the command line. |
| // For instance, RcStartupFlag("somepath/.bazelrc", "--foo") is used to |
| // represent that the line "startup --foo" was found when parsing |
| // "somepath/.bazelrc". |
| struct RcStartupFlag { |
| const std::string source; |
| const std::string value; |
| RcStartupFlag(const std::string& source_arg, |
| const std::string& value_arg) |
| : source(source_arg), value(value_arg) {} |
| }; |
| |
| // This class defines the startup options accepted by all versions Bazel, and |
| // holds the parsed values. These options and their defaults must be kept in |
| // sync with those in |
| // src/main/java/com/google/devtools/build/lib/runtime/BlazeServerStartupOptions.java. |
| // The latter are (usually) purely decorative (they affect the help message, |
| // which displays the defaults). The actual defaults are defined |
| // in the constructor. |
| // |
| // Note that this class is not thread-safe. |
| // |
| // TODO(bazel-team): The encapsulation is not quite right -- there are some |
| // places in blaze.cc where some of these fields are explicitly modified. Their |
| // names also don't conform to the style guide. |
| class StartupOptions { |
| public: |
| virtual ~StartupOptions(); |
| |
| // Process an ordered list of RcStartupFlags using ProcessArg. |
| blaze_exit_code::ExitCode ProcessArgs( |
| const std::vector<RcStartupFlag>& rcstartup_flags, |
| std::string *error); |
| |
| // Adds any other options needed to result. |
| // |
| // TODO(jmmv): Now that we support site-specific options via subclasses of |
| // StartupOptions, the "ExtraOptions" concept makes no sense; remove it. |
| virtual void AddExtraOptions(std::vector<std::string> *result) const; |
| |
| // Once startup options have been parsed, warn the user if certain options |
| // might combine in surprising ways. |
| virtual void MaybeLogStartupOptionWarnings() const = 0; |
| |
| // Returns the path to the JVM. This should be called after parsing |
| // the startup options. |
| virtual blaze_util::Path GetJvm() const; |
| |
| // Returns the executable used to start the Blaze server, typically the given |
| // JVM. |
| virtual blaze_util::Path GetExe(const blaze_util::Path &jvm, |
| const std::string &jar_path) const; |
| |
| // Adds JVM prefix flags to be set. These will be added before all other |
| // JVM flags. |
| virtual void AddJVMArgumentPrefix(const blaze_util::Path &javabase, |
| std::vector<std::string> *result) const; |
| |
| // Adds JVM suffix flags. These will be added after all other JVM flags, and |
| // just before the Blaze server startup flags. |
| virtual void AddJVMArgumentSuffix(const blaze_util::Path &real_install_dir, |
| const std::string &jar_path, |
| std::vector<std::string> *result) const; |
| |
| // Adds JVM tuning flags for Blaze. |
| // |
| // Returns the exit code after this operation. "error" will be set to a |
| // descriptive string for any value other than blaze_exit_code::SUCCESS. |
| blaze_exit_code::ExitCode AddJVMArguments( |
| const blaze_util::Path &server_javabase, std::vector<std::string> *result, |
| const std::vector<std::string> &user_options, std::string *error) const; |
| |
| // Checks whether "arg" is a valid nullary option (e.g. "--master_bazelrc" or |
| // "--nomaster_bazelrc"). |
| // |
| // Returns true, if "arg" looks like either a valid nullary option or a |
| // potentially valid unary option. In this case, "result" will be populated |
| // with true iff "arg" is definitely a valid nullary option. |
| // |
| // Returns false, if "arg" looks like an attempt to pass a value to nullary |
| // option (e.g. "--nullary_option=idontknowwhatimdoing"). In this case, |
| // "error" will be populated with a user-friendly error message. |
| // |
| // Therefore, callers of this function should look at the return value and |
| // then either look at "result" (on true) or "error" (on false). |
| bool MaybeCheckValidNullary(const std::string &arg, bool *result, |
| std::string *error) const; |
| |
| // Checks whether the argument is a valid unary option. |
| // E.g. --blazerc=foo, --blazerc foo. |
| bool IsUnary(const std::string& arg) const; |
| |
| std::string GetLowercaseProductName() const; |
| |
| // The capitalized name of this binary. |
| const std::string product_name; |
| |
| // If supplied, alternate location to write the blaze server's jvm's stdout. |
| // Otherwise a default path in the output base is used. |
| blaze_util::Path server_jvm_out; |
| |
| // If supplied, alternate location to write a serialized failure_detail proto. |
| // Otherwise a default path in the output base is used. |
| blaze_util::Path failure_detail_out; |
| |
| // Blaze's output base. Everything is relative to this. See |
| // the BlazeDirectories Java class for details. |
| blaze_util::Path output_base; |
| |
| // Installation base for a specific release installation. |
| std::string install_base; |
| |
| // The toplevel directory containing Blaze's output. When Blaze is |
| // run by a test, we use TEST_TMPDIR, simplifying the correct |
| // hermetic invocation of Blaze from tests. |
| std::string output_root; |
| |
| // Blaze's output_user_root. Used only for computing install_base and |
| // output_base. |
| std::string output_user_root; |
| |
| // Override more finegrained rc file flags and ignore them all. |
| bool ignore_all_rc_files; |
| |
| // Block for the Blaze server lock. Otherwise, |
| // quit with non-0 exit code if lock can't |
| // be acquired immediately. |
| bool block_for_lock; |
| |
| bool host_jvm_debug; |
| |
| bool autodetect_server_javabase; |
| |
| std::vector<std::string> host_jvm_args; |
| |
| bool batch; |
| |
| // From the man page: "This policy is useful for workloads that are |
| // non-interactive, but do not want to lower their nice value, and for |
| // workloads that want a deterministic scheduling policy without |
| // interactivity causing extra preemptions (between the workload's tasks)." |
| bool batch_cpu_scheduling; |
| |
| // If negative, don't mess with ionice. Otherwise, set a level from 0-7 |
| // for best-effort scheduling. 0 is highest priority, 7 is lowest. |
| int io_nice_level; |
| |
| int max_idle_secs; |
| |
| bool shutdown_on_low_sys_mem; |
| |
| bool oom_more_eagerly; |
| |
| int oom_more_eagerly_threshold; |
| |
| bool write_command_log; |
| |
| // If true, Blaze will listen to OS-level file change notifications. |
| bool watchfs; |
| |
| // Temporary flag for enabling EventBus exceptions to be fatal. |
| bool fatal_event_bus_exceptions; |
| |
| // A string to string map specifying where each option comes from. If the |
| // value is empty, it was on the command line, if it is a string, it comes |
| // from a blazerc file, if a key is not present, it is the default. |
| std::map<std::string, std::string> option_sources; |
| |
| // Returns the embedded JDK, or an empty string. |
| blaze_util::Path GetEmbeddedJavabase() const; |
| |
| // The source of truth for the server javabase. |
| enum class JavabaseType { |
| UNKNOWN, |
| // An explicit --server_javabase startup option. |
| EXPLICIT, |
| // The embedded JDK. |
| EMBEDDED, |
| // The default system JVM. |
| SYSTEM |
| }; |
| |
| // Returns the server javabase and its source of truth. This should be called |
| // after parsing the --server_javabase option. |
| std::pair<blaze_util::Path, JavabaseType> GetServerJavabaseAndType() const; |
| |
| // Returns the server javabase. This should be called after parsing the |
| // --server_javabase option. |
| blaze_util::Path GetServerJavabase() const; |
| |
| // Returns the explicit value of the --server_javabase startup option or the |
| // empty string if it was not specified on the command line. |
| blaze_util::Path GetExplicitServerJavabase() const; |
| |
| // Port to start up the gRPC command server on. If 0, let the kernel choose. |
| int command_port; |
| |
| // Connection timeout for each gRPC connection attempt. |
| int connect_timeout_secs; |
| |
| // Local server startup timeout duration. |
| int local_startup_timeout_secs; |
| |
| // Invocation policy proto, or an empty string. |
| std::string invocation_policy; |
| // Invocation policy can only be specified once. |
| bool have_invocation_policy_; |
| |
| // Whether to output addition debugging information in the client. |
| bool client_debug; |
| |
| // Whether the resulting command will be preempted if a subsequent command is |
| // run. |
| bool preemptible; |
| |
| // Value of the java.util.logging.FileHandler.formatter Java property. |
| std::string java_logging_formatter; |
| |
| bool expand_configs_in_place; |
| |
| // The hash function to use when computing file digests. |
| std::string digest_function; |
| |
| std::string unix_digest_hash_attribute_name; |
| |
| bool idle_server_tasks; |
| |
| // The startup options as received from the user and rc files, tagged with |
| // their origin. This is populated by ProcessArgs. |
| std::vector<RcStartupFlag> original_startup_options_; |
| |
| #if defined(__APPLE__) |
| // The QoS class to apply to the Bazel server process. |
| qos_class_t macos_qos_class; |
| #endif |
| |
| // Whether to raise the soft coredump limit to the hard one or not. |
| bool unlimit_coredumps; |
| |
| // Whether to create symbolic links on Windows for files. Requires |
| // developer mode to be enabled. |
| bool windows_enable_symlinks; |
| |
| protected: |
| // Constructor for subclasses only so that site-specific extensions of this |
| // class can override the product name. The product_name must be the |
| // capitalized version of the name, as in "Bazel". |
| StartupOptions(const std::string &product_name, |
| const WorkspaceLayout *workspace_layout); |
| |
| // Checks extra fields when processing arg. |
| // |
| // Returns the exit code after processing the argument. "error" will contain |
| // a descriptive string for any return value other than |
| // blaze_exit_code::SUCCESS. |
| // |
| // TODO(jmmv): Now that we support site-specific options via subclasses of |
| // StartupOptions, the "ExtraOptions" concept makes no sense; remove it. |
| virtual blaze_exit_code::ExitCode ProcessArgExtra( |
| const char *arg, const char *next_arg, const std::string &rcfile, |
| const char **value, bool *is_processed, std::string *error) = 0; |
| |
| // Checks whether the given javabase contains a java executable and runtime. |
| // On success, returns blaze_exit_code::SUCCESS. On error, prints an error |
| // message and returns an appropriate exit code with which the client should |
| // terminate. |
| blaze_exit_code::ExitCode SanityCheckJavabase( |
| const blaze_util::Path &javabase, |
| StartupOptions::JavabaseType javabase_type) const; |
| |
| // Returns the absolute path to the user's local JDK install, to be used as |
| // the default target javabase and as a fall-back host_javabase. This is not |
| // the embedded JDK. |
| virtual blaze_util::Path GetSystemJavabase() const; |
| |
| // Adds JVM logging-related flags for Bazel. |
| // |
| // This is called by StartupOptions::AddJVMArguments and is a separate method |
| // so that subclasses of StartupOptions can override it. |
| virtual void AddJVMLoggingArguments(std::vector<std::string> *result) const; |
| |
| // Adds JVM memory tuning flags for Bazel. |
| // |
| // This is called by StartupOptions::AddJVMArguments and is a separate method |
| // so that subclasses of StartupOptions can override it. |
| virtual blaze_exit_code::ExitCode AddJVMMemoryArguments( |
| const blaze_util::Path &server_javabase, std::vector<std::string> *result, |
| const std::vector<std::string> &user_options, std::string *error) const; |
| |
| virtual std::string GetRcFileBaseName() const = 0; |
| |
| void RegisterUnaryStartupFlag(const std::string& flag_name); |
| |
| // Register a nullary startup flag. |
| // Both '--flag_name' and '--noflag_name' will be registered as valid nullary |
| // flags. 'value' is the pointer to the boolean that will receive the flag's |
| // value. |
| void RegisterNullaryStartupFlag(const std::string &flag_name, bool *value); |
| |
| // Same as RegisterNullaryStartupFlag, but these flags are forbidden in |
| // .bazelrc files. |
| void RegisterNullaryStartupFlagNoRc(const std::string &flag_name, |
| bool *value); |
| |
| typedef std::function<void(bool)> SpecialNullaryFlagHandler; |
| |
| void RegisterSpecialNullaryStartupFlag(const std::string &flag_name, |
| SpecialNullaryFlagHandler handler); |
| |
| // Override the flag name to use in the 'option_sources' map. |
| void OverrideOptionSourcesKey(const std::string &flag_name, |
| const std::string &new_name); |
| |
| private: |
| // Prevent copying and moving the object to avoid invalidating pointers to |
| // members (in all_nullary_startup_flags_ for example). |
| StartupOptions() = delete; |
| StartupOptions(const StartupOptions&) = delete; |
| StartupOptions& operator=(const StartupOptions&) = delete; |
| StartupOptions(StartupOptions&&) = delete; |
| StartupOptions& operator=(StartupOptions&&) = delete; |
| |
| // Parses a single argument, either from the command line or from the .blazerc |
| // "startup" options. |
| // |
| // rcfile should be an empty string if the option being parsed does not come |
| // from a blazerc. |
| // |
| // Sets "is_space_separated" true if arg is unary and uses the "--foo bar" |
| // style, so its value is in next_arg. |
| // |
| // Sets "is_space_separated" false if arg is either nullary |
| // (e.g. "--[no]batch") or is unary but uses the "--foo=bar" style. |
| // |
| // Returns the exit code after processing the argument. "error" will contain |
| // a descriptive string for any return value other than |
| // blaze_exit_code::SUCCESS. |
| blaze_exit_code::ExitCode ProcessArg(const std::string &arg, |
| const std::string &next_arg, |
| const std::string &rcfile, |
| bool *is_space_separated, |
| std::string *error); |
| |
| // The server javabase as provided on the commandline. |
| blaze_util::Path explicit_server_javabase_; |
| |
| // The default server javabase to be used and its source of truth (computed |
| // lazily). Not guarded by a mutex - StartupOptions is not thread-safe. |
| mutable std::pair<blaze_util::Path, JavabaseType> default_server_javabase_; |
| |
| // Startup flags that don't expect a value, e.g. "home_rc". |
| // Valid uses are "--home_rc" are "--nohome_rc". |
| // Keys are positive and negative flag names (e.g. "--home_rc" and |
| // "--nohome_rc"), values are pointers to the boolean to mutate. |
| std::unordered_map<std::string, bool *> all_nullary_startup_flags_; |
| |
| // Subset of 'all_nullary_startup_flags_'. |
| // Contains positive and negative names (e.g. "--home_rc" and |
| // "--nohome_rc") of flags that must not appear in .bazelrc files. |
| std::unordered_set<std::string> no_rc_nullary_startup_flags_; |
| |
| // Subset of 'all_nullary_startup_flags_'. |
| // Contains positive and negative names (e.g. "--home_rc" and |
| // "--nohome_rc") of flags that have a special handler. |
| // Can be used for tri-state flags where omitting the flag completely means |
| // leaving the tri-state as "auto". |
| std::unordered_map<std::string, SpecialNullaryFlagHandler> |
| special_nullary_startup_flags_; |
| |
| // Startup flags that expect a value, e.g. "bazelrc". |
| // Valid uses are "--bazelrc=foo" and "--bazelrc foo". |
| // Keys are flag names (e.g. "--bazelrc"), values are pointers to the string |
| // to mutate. |
| std::unordered_set<std::string> valid_unary_startup_flags_; |
| |
| // Startup flags that use an alternative key name in the 'option_sources' map. |
| // For example, "--[no]master_bazelrc" uses "blazerc" as the map key. |
| std::unordered_map<std::string, std::string> option_sources_key_override_; |
| }; |
| |
| } // namespace blaze |
| |
| #endif // BAZEL_SRC_MAIN_CPP_STARTUP_OPTIONS_H_ |