1 // Copyright 2012 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 "engine/requirements.hpp" 30 31 #include "model/metadata.hpp" 32 #include "model/types.hpp" 33 #include "utils/config/nodes.ipp" 34 #include "utils/config/tree.ipp" 35 #include "utils/format/macros.hpp" 36 #include "utils/fs/operations.hpp" 37 #include "utils/fs/path.hpp" 38 #include "utils/memory.hpp" 39 #include "utils/passwd.hpp" 40 #include "utils/sanity.hpp" 41 #include "utils/units.hpp" 42 43 namespace config = utils::config; 44 namespace fs = utils::fs; 45 namespace passwd = utils::passwd; 46 namespace units = utils::units; 47 48 49 namespace { 50 51 52 /// Checks if all required configuration variables are present. 53 /// 54 /// \param required_configs Set of required variable names. 55 /// \param user_config Runtime user configuration. 56 /// \param test_suite_name Name of the test suite the test belongs to. 57 /// 58 /// \return Empty if all variables are present or an error message otherwise. 59 static std::string 60 check_required_configs(const model::strings_set& required_configs, 61 const config::tree& user_config, 62 const std::string& test_suite_name) 63 { 64 for (model::strings_set::const_iterator iter = required_configs.begin(); 65 iter != required_configs.end(); iter++) { 66 std::string property; 67 // TODO(jmmv): All this rewrite logic belongs in the ATF interface. 68 if ((*iter) == "unprivileged-user" || (*iter) == "unprivileged_user") 69 property = "unprivileged_user"; 70 else 71 property = F("test_suites.%s.%s") % test_suite_name % (*iter); 72 73 if (!user_config.is_set(property)) 74 return F("Required configuration property '%s' not defined") % 75 (*iter); 76 } 77 return ""; 78 } 79 80 81 /// Checks if the allowed architectures match the current architecture. 82 /// 83 /// \param allowed_architectures Set of allowed architectures. 84 /// \param user_config Runtime user configuration. 85 /// 86 /// \return Empty if the current architecture is in the list or an error 87 /// message otherwise. 88 static std::string 89 check_allowed_architectures(const model::strings_set& allowed_architectures, 90 const config::tree& user_config) 91 { 92 if (!allowed_architectures.empty()) { 93 const std::string architecture = 94 user_config.lookup< config::string_node >("architecture"); 95 if (allowed_architectures.find(architecture) == 96 allowed_architectures.end()) 97 return F("Current architecture '%s' not supported") % architecture; 98 } 99 return ""; 100 } 101 102 103 /// Checks if the allowed platforms match the current architecture. 104 /// 105 /// \param allowed_platforms Set of allowed platforms. 106 /// \param user_config Runtime user configuration. 107 /// 108 /// \return Empty if the current platform is in the list or an error message 109 /// otherwise. 110 static std::string 111 check_allowed_platforms(const model::strings_set& allowed_platforms, 112 const config::tree& user_config) 113 { 114 if (!allowed_platforms.empty()) { 115 const std::string platform = 116 user_config.lookup< config::string_node >("platform"); 117 if (allowed_platforms.find(platform) == allowed_platforms.end()) 118 return F("Current platform '%s' not supported") % platform; 119 } 120 return ""; 121 } 122 123 124 /// Checks if the current user matches the required user. 125 /// 126 /// \param required_user Name of the required user category. 127 /// \param user_config Runtime user configuration. 128 /// 129 /// \return Empty if the current user fits the required user characteristics or 130 /// an error message otherwise. 131 static std::string 132 check_required_user(const std::string& required_user, 133 const config::tree& user_config) 134 { 135 if (!required_user.empty()) { 136 const passwd::user user = passwd::current_user(); 137 if (required_user == "root") { 138 if (!user.is_root()) 139 return "Requires root privileges"; 140 } else if (required_user == "unprivileged") { 141 if (user.is_root()) 142 if (!user_config.is_set("unprivileged_user")) 143 return "Requires an unprivileged user but the " 144 "unprivileged-user configuration variable is not " 145 "defined"; 146 } else 147 UNREACHABLE_MSG("Value of require.user not properly validated"); 148 } 149 return ""; 150 } 151 152 153 /// Checks if all required files exist. 154 /// 155 /// \param required_files Set of paths. 156 /// 157 /// \return Empty if the required files all exist or an error message otherwise. 158 static std::string 159 check_required_files(const model::paths_set& required_files) 160 { 161 for (model::paths_set::const_iterator iter = required_files.begin(); 162 iter != required_files.end(); iter++) { 163 INV((*iter).is_absolute()); 164 if (!fs::exists(*iter)) 165 return F("Required file '%s' not found") % *iter; 166 } 167 return ""; 168 } 169 170 171 /// Checks if all required programs exist. 172 /// 173 /// \param required_programs Set of paths. 174 /// 175 /// \return Empty if the required programs all exist or an error message 176 /// otherwise. 177 static std::string 178 check_required_programs(const model::paths_set& required_programs) 179 { 180 for (model::paths_set::const_iterator iter = required_programs.begin(); 181 iter != required_programs.end(); iter++) { 182 if ((*iter).is_absolute()) { 183 if (!fs::exists(*iter)) 184 return F("Required program '%s' not found") % *iter; 185 } else { 186 if (!fs::find_in_path((*iter).c_str())) 187 return F("Required program '%s' not found in PATH") % *iter; 188 } 189 } 190 return ""; 191 } 192 193 194 /// Checks if the current system has the specified amount of memory. 195 /// 196 /// \param required_memory Amount of required physical memory, or zero if not 197 /// applicable. 198 /// 199 /// \return Empty if the current system has the required amount of memory or an 200 /// error message otherwise. 201 static std::string 202 check_required_memory(const units::bytes& required_memory) 203 { 204 if (required_memory > 0) { 205 const units::bytes physical_memory = utils::physical_memory(); 206 if (physical_memory > 0 && physical_memory < required_memory) 207 return F("Requires %s bytes of physical memory but only %s " 208 "available") % 209 required_memory.format() % physical_memory.format(); 210 } 211 return ""; 212 } 213 214 215 /// Checks if the work directory's file system has enough free disk space. 216 /// 217 /// \param required_disk_space Amount of required free disk space, or zero if 218 /// not applicable. 219 /// \param work_directory Path to where the test case will be run. 220 /// 221 /// \return Empty if the file system where the work directory is hosted has 222 /// enough free disk space or an error message otherwise. 223 static std::string 224 check_required_disk_space(const units::bytes& required_disk_space, 225 const fs::path& work_directory) 226 { 227 if (required_disk_space > 0) { 228 const units::bytes free_disk_space = fs::free_disk_space( 229 work_directory); 230 if (free_disk_space < required_disk_space) 231 return F("Requires %s bytes of free disk space but only %s " 232 "available") % 233 required_disk_space.format() % free_disk_space.format(); 234 } 235 return ""; 236 } 237 238 239 } // anonymous namespace 240 241 242 /// Checks if all the requirements specified by the test case are met. 243 /// 244 /// \param md The test metadata. 245 /// \param cfg The engine configuration. 246 /// \param test_suite Name of the test suite the test belongs to. 247 /// \param work_directory Path to where the test case will be run. 248 /// 249 /// \return A string describing the reason for skipping the test, or empty if 250 /// the test should be executed. 251 std::string 252 engine::check_reqs(const model::metadata& md, const config::tree& cfg, 253 const std::string& test_suite, 254 const fs::path& work_directory) 255 { 256 std::string reason; 257 258 reason = check_required_configs(md.required_configs(), cfg, test_suite); 259 if (!reason.empty()) 260 return reason; 261 262 reason = check_allowed_architectures(md.allowed_architectures(), cfg); 263 if (!reason.empty()) 264 return reason; 265 266 reason = check_allowed_platforms(md.allowed_platforms(), cfg); 267 if (!reason.empty()) 268 return reason; 269 270 reason = check_required_user(md.required_user(), cfg); 271 if (!reason.empty()) 272 return reason; 273 274 reason = check_required_files(md.required_files()); 275 if (!reason.empty()) 276 return reason; 277 278 reason = check_required_programs(md.required_programs()); 279 if (!reason.empty()) 280 return reason; 281 282 reason = check_required_memory(md.required_memory()); 283 if (!reason.empty()) 284 return reason; 285 286 reason = check_required_disk_space(md.required_disk_space(), 287 work_directory); 288 if (!reason.empty()) 289 return reason; 290 291 INV(reason.empty()); 292 return reason; 293 } 294