1 // Copyright 2011 The Kyua Authors. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above copyright 11 // notice, this list of conditions and the following disclaimer in the 12 // documentation and/or other materials provided with the distribution. 13 // * Neither the name of Google Inc. nor the names of its contributors 14 // may be used to endorse or promote products derived from this software 15 // without specific prior written permission. 16 // 17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29 #include "cli/config.hpp" 30 31 #include "cli/common.hpp" 32 #include "engine/config.hpp" 33 #include "engine/exceptions.hpp" 34 #include "utils/cmdline/options.hpp" 35 #include "utils/cmdline/parser.ipp" 36 #include "utils/config/tree.ipp" 37 #include "utils/format/macros.hpp" 38 #include "utils/fs/exceptions.hpp" 39 #include "utils/fs/operations.hpp" 40 #include "utils/fs/path.hpp" 41 #include "utils/env.hpp" 42 #include "utils/logging/macros.hpp" 43 #include "utils/optional.ipp" 44 45 namespace cmdline = utils::cmdline; 46 namespace config = utils::config; 47 namespace fs = utils::fs; 48 49 using utils::optional; 50 51 52 namespace { 53 54 55 /// Basename of the configuration file. 56 static const char* config_basename = "kyua.conf"; 57 58 59 /// Magic string to disable loading of configuration files. 60 static const char* none_config = "none"; 61 62 63 /// Textual description of the default configuration files. 64 /// 65 /// This is just an auxiliary string required to define the option below, which 66 /// requires a pointer to a static C string. 67 /// 68 /// \todo If the user overrides the KYUA_CONFDIR environment variable, we don't 69 /// reflect this fact here. We don't want to query the variable during program 70 /// initialization due to the side-effects it may have. Therefore, fixing this 71 /// is tricky as it may require a whole rethink of this module. 72 static const std::string config_lookup_names = 73 (fs::path("~/.kyua") / config_basename).str() + " or " + 74 (fs::path(KYUA_CONFDIR) / config_basename).str(); 75 76 77 /// Loads the configuration file for this session, if any. 78 /// 79 /// This is a helper function that does not apply user-specified overrides. See 80 /// the documentation for cli::load_config() for more details. 81 /// 82 /// \param cmdline The parsed command line. 83 /// 84 /// \return The loaded configuration file, or the configuration defaults if the 85 /// loading is disabled. 86 /// 87 /// \throw engine::error If the parsing of the configuration file fails. 88 /// TODO(jmmv): I'm not sure if this is the raised exception. And even if 89 /// it is, we should make it more accurate. 90 config::tree 91 load_config_file(const cmdline::parsed_cmdline& cmdline) 92 { 93 // TODO(jmmv): We should really be able to use cmdline.has_option here to 94 // detect whether the option was provided or not instead of checking against 95 // the default value. 96 const fs::path filename = cmdline.get_option< cmdline::path_option >( 97 cli::config_option.long_name()); 98 if (filename.str() == none_config) { 99 LD("Configuration loading disabled; using defaults"); 100 return engine::default_config(); 101 } else if (filename.str() != cli::config_option.default_value()) 102 return engine::load_config(filename); 103 104 const optional< fs::path > home = utils::get_home(); 105 if (home) { 106 const fs::path path = home.get() / ".kyua" / config_basename; 107 try { 108 if (fs::exists(path)) 109 return engine::load_config(path); 110 } catch (const fs::error& e) { 111 // Fall through. If we fail to load the user-specific configuration 112 // file because it cannot be openend, we try to load the system-wide 113 // one. 114 LW(F("Failed to load user-specific configuration file '%s': %s") % 115 path % e.what()); 116 } 117 } 118 119 const fs::path confdir(utils::getenv_with_default( 120 "KYUA_CONFDIR", KYUA_CONFDIR)); 121 122 const fs::path path = confdir / config_basename; 123 if (fs::exists(path)) { 124 return engine::load_config(path); 125 } else { 126 return engine::default_config(); 127 } 128 } 129 130 131 /// Loads the configuration file for this session, if any. 132 /// 133 /// This is a helper function for cli::load_config() that attempts to load the 134 /// configuration unconditionally. 135 /// 136 /// \param cmdline The parsed command line. 137 /// 138 /// \return The loaded configuration file data. 139 /// 140 /// \throw engine::error If the parsing of the configuration file fails. 141 static config::tree 142 load_required_config(const cmdline::parsed_cmdline& cmdline) 143 { 144 config::tree user_config = load_config_file(cmdline); 145 146 if (cmdline.has_option(cli::variable_option.long_name())) { 147 typedef std::pair< std::string, std::string > override_pair; 148 149 const std::vector< override_pair >& overrides = 150 cmdline.get_multi_option< cmdline::property_option >( 151 cli::variable_option.long_name()); 152 153 for (std::vector< override_pair >::const_iterator 154 iter = overrides.begin(); iter != overrides.end(); iter++) { 155 try { 156 user_config.set_string((*iter).first, (*iter).second); 157 } catch (const config::error& e) { 158 // TODO(jmmv): Raising this type from here is obviously the 159 // wrong thing to do. 160 throw engine::error(e.what()); 161 } 162 } 163 } 164 165 return user_config; 166 } 167 168 169 } // anonymous namespace 170 171 172 /// Standard definition of the option to specify a configuration file. 173 /// 174 /// You must use load_config() to load a configuration file while honoring the 175 /// value of this flag. 176 const cmdline::path_option cli::config_option( 177 'c', "config", 178 (std::string("Path to the configuration file; '") + none_config + 179 "' to disable loading").c_str(), 180 "file", config_lookup_names.c_str()); 181 182 183 /// Standard definition of the option to specify a configuration variable. 184 const cmdline::property_option cli::variable_option( 185 'v', "variable", 186 "Overrides a particular configuration variable", 187 "K=V"); 188 189 190 /// Loads the configuration file for this session, if any. 191 /// 192 /// The algorithm implemented here is as follows: 193 /// 1) If ~/.kyua/kyua.conf exists, load it. 194 /// 2) Otherwise, if sysconfdir/kyua.conf exists, load it. 195 /// 3) Otherwise, use the built-in settings. 196 /// 4) Lastly, apply any user-provided overrides. 197 /// 198 /// \param cmdline The parsed command line. 199 /// \param required Whether the loading of the configuration file must succeed. 200 /// Some commands should run regardless, and therefore we need to set this 201 /// to false for those commands. 202 /// 203 /// \return The loaded configuration file data. If required was set to false, 204 /// this might be the default configuration data if the requested file could not 205 /// be properly loaded. 206 /// 207 /// \throw engine::error If the parsing of the configuration file fails. 208 config::tree 209 cli::load_config(const cmdline::parsed_cmdline& cmdline, 210 const bool required) 211 { 212 try { 213 return load_required_config(cmdline); 214 } catch (const engine::error& e) { 215 if (required) { 216 throw; 217 } else { 218 LW(F("Ignoring failure to load configuration because the requested " 219 "command should not fail: %s") % e.what()); 220 return engine::default_config(); 221 } 222 } 223 } 224