1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "action.h" 18 19 #include <android-base/chrono_utils.h> 20 #include <android-base/logging.h> 21 #include <android-base/properties.h> 22 #include <android-base/strings.h> 23 24 #include "util.h" 25 26 using android::base::Join; 27 28 namespace android { 29 namespace init { 30 31 Command::Command(BuiltinFunction f, const std::vector<std::string>& args, int line) 32 : func_(f), args_(args), line_(line) {} 33 34 int Command::InvokeFunc() const { 35 std::vector<std::string> expanded_args; 36 expanded_args.resize(args_.size()); 37 expanded_args[0] = args_[0]; 38 for (std::size_t i = 1; i < args_.size(); ++i) { 39 if (!expand_props(args_[i], &expanded_args[i])) { 40 LOG(ERROR) << args_[0] << ": cannot expand '" << args_[i] << "'"; 41 return -EINVAL; 42 } 43 } 44 45 return func_(expanded_args); 46 } 47 48 std::string Command::BuildCommandString() const { 49 return Join(args_, ' '); 50 } 51 52 Action::Action(bool oneshot, const std::string& filename, int line) 53 : oneshot_(oneshot), filename_(filename), line_(line) {} 54 55 const KeywordMap<BuiltinFunction>* Action::function_map_ = nullptr; 56 57 bool Action::AddCommand(const std::vector<std::string>& args, int line, std::string* err) { 58 if (!function_map_) { 59 *err = "no function map available"; 60 return false; 61 } 62 63 auto function = function_map_->FindFunction(args, err); 64 if (!function) { 65 return false; 66 } 67 68 AddCommand(function, args, line); 69 return true; 70 } 71 72 void Action::AddCommand(BuiltinFunction f, const std::vector<std::string>& args, int line) { 73 commands_.emplace_back(f, args, line); 74 } 75 76 std::size_t Action::NumCommands() const { 77 return commands_.size(); 78 } 79 80 void Action::ExecuteOneCommand(std::size_t command) const { 81 // We need a copy here since some Command execution may result in 82 // changing commands_ vector by importing .rc files through parser 83 Command cmd = commands_[command]; 84 ExecuteCommand(cmd); 85 } 86 87 void Action::ExecuteAllCommands() const { 88 for (const auto& c : commands_) { 89 ExecuteCommand(c); 90 } 91 } 92 93 void Action::ExecuteCommand(const Command& command) const { 94 android::base::Timer t; 95 int result = command.InvokeFunc(); 96 97 auto duration = t.duration(); 98 // Any action longer than 50ms will be warned to user as slow operation 99 if (duration > 50ms || android::base::GetMinimumLogSeverity() <= android::base::DEBUG) { 100 std::string trigger_name = BuildTriggersString(); 101 std::string cmd_str = command.BuildCommandString(); 102 103 LOG(INFO) << "Command '" << cmd_str << "' action=" << trigger_name << " (" << filename_ 104 << ":" << command.line() << ") returned " << result << " took " 105 << duration.count() << "ms."; 106 } 107 } 108 109 bool Action::ParsePropertyTrigger(const std::string& trigger, std::string* err) { 110 const static std::string prop_str("property:"); 111 std::string prop_name(trigger.substr(prop_str.length())); 112 size_t equal_pos = prop_name.find('='); 113 if (equal_pos == std::string::npos) { 114 *err = "property trigger found without matching '='"; 115 return false; 116 } 117 118 std::string prop_value(prop_name.substr(equal_pos + 1)); 119 prop_name.erase(equal_pos); 120 121 if (auto [it, inserted] = property_triggers_.emplace(prop_name, prop_value); !inserted) { 122 *err = "multiple property triggers found for same property"; 123 return false; 124 } 125 return true; 126 } 127 128 bool Action::InitTriggers(const std::vector<std::string>& args, std::string* err) { 129 const static std::string prop_str("property:"); 130 for (std::size_t i = 0; i < args.size(); ++i) { 131 if (args[i].empty()) { 132 *err = "empty trigger is not valid"; 133 return false; 134 } 135 136 if (i % 2) { 137 if (args[i] != "&&") { 138 *err = "&& is the only symbol allowed to concatenate actions"; 139 return false; 140 } else { 141 continue; 142 } 143 } 144 145 if (!args[i].compare(0, prop_str.length(), prop_str)) { 146 if (!ParsePropertyTrigger(args[i], err)) { 147 return false; 148 } 149 } else { 150 if (!event_trigger_.empty()) { 151 *err = "multiple event triggers are not allowed"; 152 return false; 153 } 154 155 event_trigger_ = args[i]; 156 } 157 } 158 159 return true; 160 } 161 162 bool Action::InitSingleTrigger(const std::string& trigger) { 163 std::vector<std::string> name_vector{trigger}; 164 std::string err; 165 bool ret = InitTriggers(name_vector, &err); 166 if (!ret) { 167 LOG(ERROR) << "InitSingleTrigger failed due to: " << err; 168 } 169 return ret; 170 } 171 172 // This function checks that all property triggers are satisfied, that is 173 // for each (name, value) in property_triggers_, check that the current 174 // value of the property 'name' == value. 175 // 176 // It takes an optional (name, value) pair, which if provided must 177 // be present in property_triggers_; it skips the check of the current 178 // property value for this pair. 179 bool Action::CheckPropertyTriggers(const std::string& name, 180 const std::string& value) const { 181 if (property_triggers_.empty()) { 182 return true; 183 } 184 185 bool found = name.empty(); 186 for (const auto& [trigger_name, trigger_value] : property_triggers_) { 187 if (trigger_name == name) { 188 if (trigger_value != "*" && trigger_value != value) { 189 return false; 190 } else { 191 found = true; 192 } 193 } else { 194 std::string prop_val = android::base::GetProperty(trigger_name, ""); 195 if (prop_val.empty() || (trigger_value != "*" && trigger_value != prop_val)) { 196 return false; 197 } 198 } 199 } 200 return found; 201 } 202 203 bool Action::CheckEvent(const EventTrigger& event_trigger) const { 204 return event_trigger == event_trigger_ && CheckPropertyTriggers(); 205 } 206 207 bool Action::CheckEvent(const PropertyChange& property_change) const { 208 const auto& [name, value] = property_change; 209 return event_trigger_.empty() && CheckPropertyTriggers(name, value); 210 } 211 212 bool Action::CheckEvent(const BuiltinAction& builtin_action) const { 213 return this == builtin_action; 214 } 215 216 std::string Action::BuildTriggersString() const { 217 std::vector<std::string> triggers; 218 219 for (const auto& [trigger_name, trigger_value] : property_triggers_) { 220 triggers.emplace_back(trigger_name + '=' + trigger_value); 221 } 222 if (!event_trigger_.empty()) { 223 triggers.emplace_back(event_trigger_); 224 } 225 226 return Join(triggers, " && "); 227 } 228 229 void Action::DumpState() const { 230 std::string trigger_name = BuildTriggersString(); 231 LOG(INFO) << "on " << trigger_name; 232 233 for (const auto& c : commands_) { 234 std::string cmd_str = c.BuildCommandString(); 235 LOG(INFO) << " " << cmd_str; 236 } 237 } 238 239 ActionManager::ActionManager() : current_command_(0) { 240 } 241 242 ActionManager& ActionManager::GetInstance() { 243 static ActionManager instance; 244 return instance; 245 } 246 247 void ActionManager::AddAction(std::unique_ptr<Action> action) { 248 actions_.emplace_back(std::move(action)); 249 } 250 251 void ActionManager::QueueEventTrigger(const std::string& trigger) { 252 event_queue_.emplace(trigger); 253 } 254 255 void ActionManager::QueuePropertyChange(const std::string& name, const std::string& value) { 256 event_queue_.emplace(std::make_pair(name, value)); 257 } 258 259 void ActionManager::QueueAllPropertyActions() { 260 QueuePropertyChange("", ""); 261 } 262 263 void ActionManager::QueueBuiltinAction(BuiltinFunction func, const std::string& name) { 264 auto action = std::make_unique<Action>(true, "<Builtin Action>", 0); 265 std::vector<std::string> name_vector{name}; 266 267 if (!action->InitSingleTrigger(name)) { 268 return; 269 } 270 271 action->AddCommand(func, name_vector, 0); 272 273 event_queue_.emplace(action.get()); 274 actions_.emplace_back(std::move(action)); 275 } 276 277 void ActionManager::ExecuteOneCommand() { 278 // Loop through the event queue until we have an action to execute 279 while (current_executing_actions_.empty() && !event_queue_.empty()) { 280 for (const auto& action : actions_) { 281 if (std::visit([&action](const auto& event) { return action->CheckEvent(event); }, 282 event_queue_.front())) { 283 current_executing_actions_.emplace(action.get()); 284 } 285 } 286 event_queue_.pop(); 287 } 288 289 if (current_executing_actions_.empty()) { 290 return; 291 } 292 293 auto action = current_executing_actions_.front(); 294 295 if (current_command_ == 0) { 296 std::string trigger_name = action->BuildTriggersString(); 297 LOG(INFO) << "processing action (" << trigger_name << ") from (" << action->filename() 298 << ":" << action->line() << ")"; 299 } 300 301 action->ExecuteOneCommand(current_command_); 302 303 // If this was the last command in the current action, then remove 304 // the action from the executing list. 305 // If this action was oneshot, then also remove it from actions_. 306 ++current_command_; 307 if (current_command_ == action->NumCommands()) { 308 current_executing_actions_.pop(); 309 current_command_ = 0; 310 if (action->oneshot()) { 311 auto eraser = [&action] (std::unique_ptr<Action>& a) { 312 return a.get() == action; 313 }; 314 actions_.erase(std::remove_if(actions_.begin(), actions_.end(), eraser)); 315 } 316 } 317 } 318 319 bool ActionManager::HasMoreCommands() const { 320 return !current_executing_actions_.empty() || !event_queue_.empty(); 321 } 322 323 void ActionManager::DumpState() const { 324 for (const auto& a : actions_) { 325 a->DumpState(); 326 } 327 } 328 329 void ActionManager::ClearQueue() { 330 // We are shutting down so don't claim the oneshot builtin actions back 331 current_executing_actions_ = {}; 332 event_queue_ = {}; 333 current_command_ = 0; 334 } 335 336 bool ActionParser::ParseSection(std::vector<std::string>&& args, const std::string& filename, 337 int line, std::string* err) { 338 std::vector<std::string> triggers(args.begin() + 1, args.end()); 339 if (triggers.size() < 1) { 340 *err = "actions must have a trigger"; 341 return false; 342 } 343 344 auto action = std::make_unique<Action>(false, filename, line); 345 if (!action->InitTriggers(triggers, err)) { 346 return false; 347 } 348 349 action_ = std::move(action); 350 return true; 351 } 352 353 bool ActionParser::ParseLineSection(std::vector<std::string>&& args, int line, std::string* err) { 354 return action_ ? action_->AddCommand(std::move(args), line, err) : false; 355 } 356 357 void ActionParser::EndSection() { 358 if (action_ && action_->NumCommands() > 0) { 359 action_manager_->AddAction(std::move(action_)); 360 } 361 } 362 363 } // namespace init 364 } // namespace android 365