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
check_required_configs(const model::strings_set & required_configs,const config::tree & user_config,const std::string & test_suite_name)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
check_allowed_architectures(const model::strings_set & allowed_architectures,const config::tree & user_config)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
check_allowed_platforms(const model::strings_set & allowed_platforms,const config::tree & user_config)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
check_required_user(const std::string & required_user,const config::tree & user_config)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
check_required_files(const model::paths_set & required_files)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
check_required_programs(const model::paths_set & required_programs)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
check_required_memory(const units::bytes & required_memory)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
check_required_disk_space(const units::bytes & required_disk_space,const fs::path & work_directory)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
check_reqs(const model::metadata & md,const config::tree & cfg,const std::string & test_suite,const fs::path & work_directory)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