| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 __MASTER_FLAGS_HPP__ |
| #define __MASTER_FLAGS_HPP__ |
| |
| #include <string> |
| |
| #include <stout/duration.hpp> |
| #include <stout/flags.hpp> |
| #include <stout/json.hpp> |
| #include <stout/option.hpp> |
| #include <stout/protobuf.hpp> |
| |
| #include "common/parse.hpp" |
| |
| #include "logging/flags.hpp" |
| |
| #include "master/constants.hpp" |
| |
| #include "mesos/mesos.hpp" |
| |
| namespace mesos { |
| namespace internal { |
| namespace master { |
| |
| class Flags : public logging::Flags |
| { |
| public: |
| Flags() |
| { |
| add(&Flags::version, |
| "version", |
| "Show version and exit.", |
| false); |
| |
| add(&Flags::hostname, |
| "hostname", |
| "The hostname the master should advertise in ZooKeeper.\n" |
| "If left unset, system hostname will be used (recommended)."); |
| |
| add(&Flags::root_submissions, |
| "root_submissions", |
| "Can root submit frameworks?", |
| true); |
| |
| add(&Flags::work_dir, |
| "work_dir", |
| "Directory path to store the persistent information stored in the \n" |
| "Registry. (example: /var/lib/mesos/master)"); |
| |
| // TODO(bmahler): Consider removing 'in_memory' as it was only |
| // used before 'replicated_log' was implemented. |
| add(&Flags::registry, |
| "registry", |
| "Persistence strategy for the registry;\n" |
| "available options are 'replicated_log', 'in_memory' (for testing).", |
| "replicated_log"); |
| |
| // TODO(vinod): Instead of specifying the quorum size consider |
| // specifying the number of masters or the list of masters. |
| add(&Flags::quorum, |
| "quorum", |
| "The size of the quorum of replicas when using 'replicated_log' based\n" |
| "registry. It is imperative to set this value to be a majority of\n" |
| "masters i.e., quorum > (number of masters)/2."); |
| |
| add(&Flags::zk_session_timeout, |
| "zk_session_timeout", |
| "ZooKeeper session timeout.", |
| ZOOKEEPER_SESSION_TIMEOUT); |
| |
| // TODO(bmahler): Set the default to true in 0.20.0. |
| add(&Flags::registry_strict, |
| "registry_strict", |
| "Whether the Master will take actions based on the persistent\n" |
| "information stored in the Registry. Setting this to false means\n" |
| "that the Registrar will never reject the admission, readmission,\n" |
| "or removal of a slave. Consequently, 'false' can be used to\n" |
| "bootstrap the persistent state on a running cluster.\n" |
| "NOTE: This flag is *experimental* and should not be used in\n" |
| "production yet.", |
| false); |
| |
| add(&Flags::registry_fetch_timeout, |
| "registry_fetch_timeout", |
| "Duration of time to wait in order to fetch data from the registry\n" |
| "after which the operation is considered a failure.", |
| Seconds(60)); |
| |
| add(&Flags::registry_store_timeout, |
| "registry_store_timeout", |
| "Duration of time to wait in order to store data in the registry\n" |
| "after which the operation is considered a failure.", |
| Seconds(5)); |
| |
| add(&Flags::log_auto_initialize, |
| "log_auto_initialize", |
| "Whether to automatically initialize the replicated log used for the\n" |
| "registry. If this is set to false, the log has to be manually\n" |
| "initialized when used for the very first time.", |
| true); |
| |
| add(&Flags::slave_reregister_timeout, |
| "slave_reregister_timeout", |
| "The timeout within which all slaves are expected to re-register\n" |
| "when a new master is elected as the leader. Slaves that do not\n" |
| "re-register within the timeout will be removed from the registry\n" |
| "and will be shutdown if they attempt to communicate with master.\n" |
| "NOTE: This value has to be atleast " + |
| stringify(MIN_SLAVE_REREGISTER_TIMEOUT) + ".", |
| MIN_SLAVE_REREGISTER_TIMEOUT); |
| |
| // TODO(bmahler): Add a 'Percentage' abstraction for flags. |
| // TODO(bmahler): Add a --production flag for production defaults. |
| add(&Flags::recovery_slave_removal_limit, |
| "recovery_slave_removal_limit", |
| "For failovers, limit on the percentage of slaves that can be removed\n" |
| "from the registry *and* shutdown after the re-registration timeout\n" |
| "elapses. If the limit is exceeded, the master will fail over rather\n" |
| "than remove the slaves.\n" |
| "This can be used to provide safety guarantees for production\n" |
| "environments. Production environments may expect that across Master\n" |
| "failovers, at most a certain percentage of slaves will fail\n" |
| "permanently (e.g. due to rack-level failures).\n" |
| "Setting this limit would ensure that a human needs to get\n" |
| "involved should an unexpected widespread failure of slaves occur\n" |
| "in the cluster.\n" |
| "Values: [0%-100%]", |
| stringify(RECOVERY_SLAVE_REMOVAL_PERCENT_LIMIT * 100.0) + "%"); |
| |
| add(&Flags::webui_dir, |
| "webui_dir", |
| "Directory path of the webui files/assets", |
| PKGDATADIR "/webui"); |
| |
| add(&Flags::whitelist, |
| "whitelist", |
| "Path to a file with a list of slaves\n" |
| "(one per line) to advertise offers for.\n" |
| "Path could be of the form 'file:///path/to/file' or '/path/to/file'.", |
| "*"); |
| |
| add(&Flags::user_sorter, |
| "user_sorter", |
| "Policy to use for allocating resources\n" |
| "between users. May be one of:\n" |
| " dominant_resource_fairness (drf)", |
| "drf"); |
| |
| add(&Flags::framework_sorter, |
| "framework_sorter", |
| "Policy to use for allocating resources\n" |
| "between a given user's frameworks. Options\n" |
| "are the same as for user_allocator.", |
| "drf"); |
| |
| add(&Flags::allocation_interval, |
| "allocation_interval", |
| "Amount of time to wait between performing\n" |
| " (batch) allocations (e.g., 500ms, 1sec, etc).", |
| Seconds(1)); |
| |
| add(&Flags::cluster, |
| "cluster", |
| "Human readable name for the cluster,\n" |
| "displayed in the webui."); |
| |
| // TODO(vinod): Deprecate this in favor of '--acls'. |
| add(&Flags::roles, |
| "roles", |
| "A comma separated list of the allocation\n" |
| "roles that frameworks in this cluster may\n" |
| "belong to."); |
| |
| add(&Flags::weights, |
| "weights", |
| "A comma seperated list of role/weight pairs\n" |
| "of the form 'role=weight,role=weight'. Weights\n" |
| "are used to indicate forms of priority."); |
| |
| // TODO(adam-mesos): Deprecate --authenticate for --authenticate_frameworks. |
| add(&Flags::authenticate_frameworks, |
| "authenticate", |
| "If authenticate is 'true' only authenticated frameworks are allowed\n" |
| "to register. If 'false' unauthenticated frameworks are also\n" |
| "allowed to register.", |
| false); |
| |
| add(&Flags::authenticate_slaves, |
| "authenticate_slaves", |
| "If 'true' only authenticated slaves are allowed to register.\n" |
| "If 'false' unauthenticated slaves are also allowed to register.", |
| false); |
| |
| add(&Flags::credentials, |
| "credentials", |
| "Either a path to a text file with a list of credentials,\n" |
| "each line containing 'principal' and 'secret' separated by " |
| "whitespace,\n" |
| "or, a path to a JSON-formatted file containing credentials.\n" |
| "Path could be of the form 'file:///path/to/file' or '/path/to/file'." |
| "\n" |
| "JSON file Example:\n" |
| "{\n" |
| " \"credentials\": [\n" |
| " {\n" |
| " \"principal\": \"sherman\",\n" |
| " \"secret\": \"kitesurf\",\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "Text file Example:\n" |
| "username secret\n" |
| ); |
| |
| add(&Flags::acls, |
| "acls", |
| "The value could be a JSON formatted string of ACLs\n" |
| "or a file path containing the JSON formatted ACLs used\n" |
| "for authorization. Path could be of the form 'file:///path/to/file'\n" |
| "or '/path/to/file'.\n" |
| "\n" |
| "See the ACLs protobuf in mesos.proto for the expected format.\n" |
| "\n" |
| "Example:\n" |
| "{\n" |
| " \"register_frameworks\": [\n" |
| " {\n" |
| " \"principals\": { \"type\": \"ANY\" },\n" |
| " \"roles\": { \"values\": [\"a\"] }\n" |
| " }\n" |
| " ],\n" |
| " \"run_tasks\": [\n" |
| " {\n" |
| " \"principals\": { \"values\": [\"a\", \"b\"] },\n" |
| " \"users\": { \"values\": [\"c\"] }\n" |
| " }\n" |
| " ],\n" |
| " \"shutdown_frameworks\": [\n" |
| " {\n" |
| " \"principals\": { \"values\": [\"a\", \"b\"] },\n" |
| " \"framework_principals\": { \"values\": [\"c\"] }\n" |
| " }\n" |
| " ]\n" |
| "}"); |
| |
| add(&Flags::rate_limits, |
| "rate_limits", |
| "The value could be a JSON formatted string of rate limits\n" |
| "or a file path containing the JSON formatted rate limits used\n" |
| "for framework rate limiting.\n" |
| "Path could be of the form 'file:///path/to/file'\n" |
| "or '/path/to/file'.\n" |
| "\n" |
| "See the RateLimits protobuf in mesos.proto for the expected format.\n" |
| "\n" |
| "Example:\n" |
| "{\n" |
| " \"limits\": [\n" |
| " {\n" |
| " \"principal\": \"foo\",\n" |
| " \"qps\": 55.5\n" |
| " },\n" |
| " {\n" |
| " \"principal\": \"bar\"\n" |
| " }\n" |
| " ],\n" |
| " \"aggregate_default_qps\": 33.3\n" |
| "}"); |
| |
| #ifdef WITH_NETWORK_ISOLATOR |
| add(&Flags::max_executors_per_slave, |
| "max_executors_per_slave", |
| "A maximum number of executors to allow per slave."); |
| #endif // WITH_NETWORK_ISOLATOR |
| } |
| |
| bool version; |
| Option<std::string> hostname; |
| bool root_submissions; |
| Option<std::string> work_dir; |
| std::string registry; |
| Option<int> quorum; |
| Duration zk_session_timeout; |
| bool registry_strict; |
| Duration registry_fetch_timeout; |
| Duration registry_store_timeout; |
| bool log_auto_initialize; |
| Duration slave_reregister_timeout; |
| std::string recovery_slave_removal_limit; |
| std::string webui_dir; |
| std::string whitelist; |
| std::string user_sorter; |
| std::string framework_sorter; |
| Duration allocation_interval; |
| Option<std::string> cluster; |
| Option<std::string> roles; |
| Option<std::string> weights; |
| bool authenticate_frameworks; |
| bool authenticate_slaves; |
| Option<std::string> credentials; |
| Option<ACLs> acls; |
| Option<RateLimits> rate_limits; |
| |
| #ifdef WITH_NETWORK_ISOLATOR |
| Option<size_t> max_executors_per_slave; |
| #endif // WITH_NETWORK_ISOLATOR |
| }; |
| |
| } // namespace master { |
| } // namespace internal { |
| } // namespace mesos { |
| |
| #endif // __MASTER_FLAGS_HPP__ |
