1 /*
2 * Copyright 2019 Google Inc.
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 "general_systemd.hpp"
18
19 #include "status.hpp"
20
21 #include <sdbusplus/bus.hpp>
22
23 #include <fstream>
24 #include <memory>
25 #include <string>
26 #include <vector>
27
28 namespace ipmi_flash
29 {
30
31 static constexpr auto systemdService = "org.freedesktop.systemd1";
32 static constexpr auto systemdRoot = "/org/freedesktop/systemd1";
33 static constexpr auto systemdInterface = "org.freedesktop.systemd1.Manager";
34 static constexpr auto jobInterface = "org.freedesktop.systemd1.Job";
35
trigger()36 bool SystemdNoFile::trigger()
37 {
38 if (job)
39 {
40 std::fprintf(stderr, "Job alreading running %s: %s\n",
41 triggerService.c_str(), job->c_str());
42 return false;
43 }
44
45 try
46 {
47 jobMonitor.emplace(bus,
48 "type='signal',"
49 "sender='org.freedesktop.systemd1',"
50 "path='/org/freedesktop/systemd1',"
51 "interface='org.freedesktop.systemd1.Manager',"
52 "member='JobRemoved',",
53 [&](sdbusplus::message_t& m) { this->match(m); });
54
55 auto method = bus.new_method_call(systemdService, systemdRoot,
56 systemdInterface, "StartUnit");
57 method.append(triggerService);
58 method.append(mode);
59
60 sdbusplus::message::object_path obj_path;
61 bus.call(method).read(obj_path);
62 job = std::move(obj_path);
63 std::fprintf(stderr, "Triggered %s mode %s: %s\n",
64 triggerService.c_str(), mode.c_str(), job->c_str());
65 currentStatus = ActionStatus::running;
66 return true;
67 }
68 catch (const std::exception& e)
69 {
70 job = std::nullopt;
71 jobMonitor = std::nullopt;
72 currentStatus = ActionStatus::failed;
73 std::fprintf(stderr, "Failed to trigger %s mode %s: %s\n",
74 triggerService.c_str(), mode.c_str(), e.what());
75 return false;
76 }
77 }
78
abort()79 void SystemdNoFile::abort()
80 {
81 if (!job)
82 {
83 return;
84 }
85
86 // Cancel the job
87 auto cancel_req = bus.new_method_call(systemdService, job->c_str(),
88 jobInterface, "Cancel");
89 try
90 {
91 bus.call_noreply(cancel_req);
92 std::fprintf(stderr, "Canceled %s: %s\n", triggerService.c_str(),
93 job->c_str());
94 }
95 catch (const sdbusplus::exception_t& ex)
96 {
97 std::fprintf(stderr, "Failed to cancel job %s %s: %s\n",
98 triggerService.c_str(), job->c_str(), ex.what());
99 }
100 }
101
status()102 ActionStatus SystemdNoFile::status()
103 {
104 return currentStatus;
105 }
106
getMode() const107 const std::string& SystemdNoFile::getMode() const
108 {
109 return mode;
110 }
111
match(sdbusplus::message_t & m)112 void SystemdNoFile::match(sdbusplus::message_t& m)
113 {
114 if (!job)
115 {
116 std::fprintf(stderr, "No running job %s\n", triggerService.c_str());
117 return;
118 }
119
120 uint32_t job_id;
121 sdbusplus::message::object_path job_path;
122 std::string unit;
123 std::string result;
124 try
125 {
126 m.read(job_id, job_path, unit, result);
127 }
128 catch (const sdbusplus::exception_t& e)
129 {
130 std::fprintf(stderr, "Bad JobRemoved signal %s: %s\n",
131 triggerService.c_str(), e.what());
132 return;
133 }
134
135 if (*job != job_path.str)
136 {
137 return;
138 }
139
140 std::fprintf(stderr, "Job Finished %s %s: %s\n", triggerService.c_str(),
141 job->c_str(), result.c_str());
142 jobMonitor = std::nullopt;
143 job = std::nullopt;
144 currentStatus = result == "done" ? ActionStatus::success
145 : ActionStatus::failed;
146
147 if (cb)
148 {
149 cb(*this);
150 }
151 }
152
CreateSystemdNoFile(sdbusplus::bus_t && bus,const std::string & service,const std::string & mode)153 std::unique_ptr<TriggerableActionInterface> SystemdNoFile::CreateSystemdNoFile(
154 sdbusplus::bus_t&& bus, const std::string& service, const std::string& mode)
155 {
156 return std::make_unique<SystemdNoFile>(std::move(bus), service, mode);
157 }
158
159 std::unique_ptr<TriggerableActionInterface>
CreateSystemdWithStatusFile(sdbusplus::bus_t && bus,const std::string & path,const std::string & service,const std::string & mode)160 SystemdWithStatusFile::CreateSystemdWithStatusFile(
161 sdbusplus::bus_t&& bus, const std::string& path,
162 const std::string& service, const std::string& mode)
163 {
164 return std::make_unique<SystemdWithStatusFile>(std::move(bus), path,
165 service, mode);
166 }
167
trigger()168 bool SystemdWithStatusFile::trigger()
169 {
170 if (SystemdNoFile::status() != ActionStatus::running)
171 {
172 try
173 {
174 std::ofstream ofs;
175 ofs.open(checkPath);
176 ofs << "unknown";
177 }
178 catch (const std::exception& e)
179 {
180 return false;
181 }
182 }
183 return SystemdNoFile::trigger();
184 }
185
status()186 ActionStatus SystemdWithStatusFile::status()
187 {
188 // Assume a status based on job execution if there is no file
189 ActionStatus result = SystemdNoFile::status() == ActionStatus::running
190 ? ActionStatus::running
191 : ActionStatus::failed;
192
193 std::ifstream ifs;
194 ifs.open(checkPath);
195 if (ifs.good())
196 {
197 /*
198 * Check for the contents of the file, accepting:
199 * running, success, or failed.
200 */
201 std::string status;
202 ifs >> status;
203 if (status == "running")
204 {
205 result = ActionStatus::running;
206 }
207 else if (status == "success")
208 {
209 result = ActionStatus::success;
210 }
211 else if (status == "failed")
212 {
213 result = ActionStatus::failed;
214 }
215 else
216 {
217 result = ActionStatus::unknown;
218 }
219 }
220
221 return result;
222 }
223
224 } // namespace ipmi_flash
225