xref: /openbmc/bmcweb/redfish-core/lib/task.hpp (revision 6c58a03e) 
1 /*
2 Copyright (c) 2020 Intel Corporation
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 #pragma once
17 
18 #include "app.hpp"
19 #include "dbus_utility.hpp"
20 #include "event_service_manager.hpp"
21 #include "generated/enums/resource.hpp"
22 #include "generated/enums/task_service.hpp"
23 #include "http/parsing.hpp"
24 #include "query.hpp"
25 #include "registries/privilege_registry.hpp"
26 #include "task_messages.hpp"
27 
28 #include <boost/asio/post.hpp>
29 #include <boost/asio/steady_timer.hpp>
30 #include <boost/url/format.hpp>
31 #include <sdbusplus/bus/match.hpp>
32 
33 #include <chrono>
34 #include <memory>
35 #include <ranges>
36 #include <variant>
37 
38 namespace redfish
39 {
40 
41 namespace task
42 {
43 constexpr size_t maxTaskCount = 100; // arbitrary limit
44 
45 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
46 static std::deque<std::shared_ptr<struct TaskData>> tasks;
47 
48 constexpr bool completed = true;
49 
50 struct Payload
51 {
52     explicit Payload(const crow::Request& req) :
53         targetUri(req.url().encoded_path()), httpOperation(req.methodString()),
54         httpHeaders(nlohmann::json::array())
55     {
56         using field_ns = boost::beast::http::field;
57         constexpr const std::array<boost::beast::http::field, 7>
58             headerWhitelist = {field_ns::accept,     field_ns::accept_encoding,
59                                field_ns::user_agent, field_ns::host,
60                                field_ns::connection, field_ns::content_length,
61                                field_ns::upgrade};
62 
63         JsonParseResult ret = parseRequestAsJson(req, jsonBody);
64         if (ret != JsonParseResult::Success)
65         {
66             return;
67         }
68 
69         for (const auto& field : req.fields())
70         {
71             if (std::ranges::find(headerWhitelist, field.name()) ==
72                 headerWhitelist.end())
73             {
74                 continue;
75             }
76             std::string header;
77             header.reserve(
78                 field.name_string().size() + 2 + field.value().size());
79             header += field.name_string();
80             header += ": ";
81             header += field.value();
82             httpHeaders.emplace_back(std::move(header));
83         }
84     }
85     Payload() = delete;
86 
87     std::string targetUri;
88     std::string httpOperation;
89     nlohmann::json httpHeaders;
90     nlohmann::json jsonBody;
91 };
92 
93 struct TaskData : std::enable_shared_from_this<TaskData>
94 {
95   private:
96     TaskData(
97         std::function<bool(boost::system::error_code, sdbusplus::message_t&,
98                            const std::shared_ptr<TaskData>&)>&& handler,
99         const std::string& matchIn, size_t idx) :
100         callback(std::move(handler)), matchStr(matchIn), index(idx),
101         startTime(std::chrono::system_clock::to_time_t(
102             std::chrono::system_clock::now())),
103         status("OK"), state("Running"), messages(nlohmann::json::array()),
104         timer(crow::connections::systemBus->get_io_context())
105 
106     {}
107 
108   public:
109     TaskData() = delete;
110 
111     static std::shared_ptr<TaskData>& createTask(
112         std::function<bool(boost::system::error_code, sdbusplus::message_t&,
113                            const std::shared_ptr<TaskData>&)>&& handler,
114         const std::string& match)
115     {
116         static size_t lastTask = 0;
117         struct MakeSharedHelper : public TaskData
118         {
119             MakeSharedHelper(
120                 std::function<bool(boost::system::error_code,
121                                    sdbusplus::message_t&,
122                                    const std::shared_ptr<TaskData>&)>&& handler,
123                 const std::string& match2, size_t idx) :
124                 TaskData(std::move(handler), match2, idx)
125             {}
126         };
127 
128         if (tasks.size() >= maxTaskCount)
129         {
130             const auto& last = tasks.front();
131 
132             // destroy all references
133             last->timer.cancel();
134             last->match.reset();
135             tasks.pop_front();
136         }
137 
138         return tasks.emplace_back(std::make_shared<MakeSharedHelper>(
139             std::move(handler), match, lastTask++));
140     }
141 
142     void populateResp(crow::Response& res, size_t retryAfterSeconds = 30)
143     {
144         if (!endTime)
145         {
146             res.result(boost::beast::http::status::accepted);
147             std::string strIdx = std::to_string(index);
148             boost::urls::url uri =
149                 boost::urls::format("/redfish/v1/TaskService/Tasks/{}", strIdx);
150 
151             res.jsonValue["@odata.id"] = uri;
152             res.jsonValue["@odata.type"] = "#Task.v1_4_3.Task";
153             res.jsonValue["Id"] = strIdx;
154             res.jsonValue["TaskState"] = state;
155             res.jsonValue["TaskStatus"] = status;
156 
157             boost::urls::url taskMonitor = boost::urls::format(
158                 "/redfish/v1/TaskService/TaskMonitors/{}", strIdx);
159 
160             res.addHeader(boost::beast::http::field::location,
161                           taskMonitor.buffer());
162             res.addHeader(boost::beast::http::field::retry_after,
163                           std::to_string(retryAfterSeconds));
164         }
165         else if (!gave204)
166         {
167             res.result(boost::beast::http::status::no_content);
168             gave204 = true;
169         }
170     }
171 
172     void finishTask()
173     {
174         endTime = std::chrono::system_clock::to_time_t(
175             std::chrono::system_clock::now());
176     }
177 
178     void extendTimer(const std::chrono::seconds& timeout)
179     {
180         timer.expires_after(timeout);
181         timer.async_wait(
182             [self = shared_from_this()](boost::system::error_code ec) {
183                 if (ec == boost::asio::error::operation_aborted)
184                 {
185                     return; // completed successfully
186                 }
187                 if (!ec)
188                 {
189                     // change ec to error as timer expired
190                     ec = boost::asio::error::operation_aborted;
191                 }
192                 self->match.reset();
193                 sdbusplus::message_t msg;
194                 self->finishTask();
195                 self->state = "Cancelled";
196                 self->status = "Warning";
197                 self->messages.emplace_back(
198                     messages::taskAborted(std::to_string(self->index)));
199                 // Send event :TaskAborted
200                 self->sendTaskEvent(self->state, self->index);
201                 self->callback(ec, msg, self);
202             });
203     }
204 
205     static void sendTaskEvent(std::string_view state, size_t index)
206     {
207         // TaskState enums which should send out an event are:
208         // "Starting" = taskResumed
209         // "Running" = taskStarted
210         // "Suspended" = taskPaused
211         // "Interrupted" = taskPaused
212         // "Pending" = taskPaused
213         // "Stopping" = taskAborted
214         // "Completed" = taskCompletedOK
215         // "Killed" = taskRemoved
216         // "Exception" = taskCompletedWarning
217         // "Cancelled" = taskCancelled
218         nlohmann::json event;
219         std::string indexStr = std::to_string(index);
220         if (state == "Starting")
221         {
222             event = redfish::messages::taskResumed(indexStr);
223         }
224         else if (state == "Running")
225         {
226             event = redfish::messages::taskStarted(indexStr);
227         }
228         else if ((state == "Suspended") || (state == "Interrupted") ||
229                  (state == "Pending"))
230         {
231             event = redfish::messages::taskPaused(indexStr);
232         }
233         else if (state == "Stopping")
234         {
235             event = redfish::messages::taskAborted(indexStr);
236         }
237         else if (state == "Completed")
238         {
239             event = redfish::messages::taskCompletedOK(indexStr);
240         }
241         else if (state == "Killed")
242         {
243             event = redfish::messages::taskRemoved(indexStr);
244         }
245         else if (state == "Exception")
246         {
247             event = redfish::messages::taskCompletedWarning(indexStr);
248         }
249         else if (state == "Cancelled")
250         {
251             event = redfish::messages::taskCancelled(indexStr);
252         }
253         else
254         {
255             BMCWEB_LOG_INFO("sendTaskEvent: No events to send");
256             return;
257         }
258         boost::urls::url origin =
259             boost::urls::format("/redfish/v1/TaskService/Tasks/{}", index);
260         EventServiceManager::getInstance().sendEvent(event, origin.buffer(),
261                                                      "Task");
262     }
263 
264     void startTimer(const std::chrono::seconds& timeout)
265     {
266         if (match)
267         {
268             return;
269         }
270         match = std::make_unique<sdbusplus::bus::match_t>(
271             static_cast<sdbusplus::bus_t&>(*crow::connections::systemBus),
272             matchStr,
273             [self = shared_from_this()](sdbusplus::message_t& message) {
274                 boost::system::error_code ec;
275 
276                 // callback to return True if callback is done, callback needs
277                 // to update status itself if needed
278                 if (self->callback(ec, message, self) == task::completed)
279                 {
280                     self->timer.cancel();
281                     self->finishTask();
282 
283                     // Send event
284                     self->sendTaskEvent(self->state, self->index);
285 
286                     // reset the match after the callback was successful
287                     boost::asio::post(
288                         crow::connections::systemBus->get_io_context(),
289                         [self] { self->match.reset(); });
290                     return;
291                 }
292             });
293 
294         extendTimer(timeout);
295         messages.emplace_back(messages::taskStarted(std::to_string(index)));
296         // Send event : TaskStarted
297         sendTaskEvent(state, index);
298     }
299 
300     std::function<bool(boost::system::error_code, sdbusplus::message_t&,
301                        const std::shared_ptr<TaskData>&)>
302         callback;
303     std::string matchStr;
304     size_t index;
305     time_t startTime;
306     std::string status;
307     std::string state;
308     nlohmann::json messages;
309     boost::asio::steady_timer timer;
310     std::unique_ptr<sdbusplus::bus::match_t> match;
311     std::optional<time_t> endTime;
312     std::optional<Payload> payload;
313     bool gave204 = false;
314     int percentComplete = 0;
315 };
316 
317 } // namespace task
318 
319 inline void requestRoutesTaskMonitor(App& app)
320 {
321     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/TaskMonitors/<str>/")
322         .privileges(redfish::privileges::getTask)
323         .methods(boost::beast::http::verb::get)(
324             [&app](const crow::Request& req,
325                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
326                    const std::string& strParam) {
327                 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
328                 {
329                     return;
330                 }
331                 auto find = std::ranges::find_if(
332                     task::tasks,
333                     [&strParam](const std::shared_ptr<task::TaskData>& task) {
334                         if (!task)
335                         {
336                             return false;
337                         }
338 
339                         // we compare against the string version as on failure
340                         // strtoul returns 0
341                         return std::to_string(task->index) == strParam;
342                     });
343 
344                 if (find == task::tasks.end())
345                 {
346                     messages::resourceNotFound(asyncResp->res, "Task",
347                                                strParam);
348                     return;
349                 }
350                 std::shared_ptr<task::TaskData>& ptr = *find;
351                 // monitor expires after 204
352                 if (ptr->gave204)
353                 {
354                     messages::resourceNotFound(asyncResp->res, "Task",
355                                                strParam);
356                     return;
357                 }
358                 ptr->populateResp(asyncResp->res);
359             });
360 }
361 
362 inline void requestRoutesTask(App& app)
363 {
364     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/<str>/")
365         .privileges(redfish::privileges::getTask)
366         .methods(boost::beast::http::verb::get)(
367             [&app](const crow::Request& req,
368                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
369                    const std::string& strParam) {
370                 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
371                 {
372                     return;
373                 }
374                 auto find = std::ranges::find_if(
375                     task::tasks,
376                     [&strParam](const std::shared_ptr<task::TaskData>& task) {
377                         if (!task)
378                         {
379                             return false;
380                         }
381 
382                         // we compare against the string version as on failure
383                         // strtoul returns 0
384                         return std::to_string(task->index) == strParam;
385                     });
386 
387                 if (find == task::tasks.end())
388                 {
389                     messages::resourceNotFound(asyncResp->res, "Task",
390                                                strParam);
391                     return;
392                 }
393 
394                 const std::shared_ptr<task::TaskData>& ptr = *find;
395 
396                 asyncResp->res.jsonValue["@odata.type"] = "#Task.v1_4_3.Task";
397                 asyncResp->res.jsonValue["Id"] = strParam;
398                 asyncResp->res.jsonValue["Name"] = "Task " + strParam;
399                 asyncResp->res.jsonValue["TaskState"] = ptr->state;
400                 asyncResp->res.jsonValue["StartTime"] =
401                     redfish::time_utils::getDateTimeStdtime(ptr->startTime);
402                 if (ptr->endTime)
403                 {
404                     asyncResp->res.jsonValue["EndTime"] =
405                         redfish::time_utils::getDateTimeStdtime(
406                             *(ptr->endTime));
407                 }
408                 asyncResp->res.jsonValue["TaskStatus"] = ptr->status;
409                 asyncResp->res.jsonValue["Messages"] = ptr->messages;
410                 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
411                     "/redfish/v1/TaskService/Tasks/{}", strParam);
412                 if (!ptr->gave204)
413                 {
414                     asyncResp->res.jsonValue["TaskMonitor"] =
415                         boost::urls::format(
416                             "/redfish/v1/TaskService/TaskMonitors/{}",
417                             strParam);
418                 }
419 
420                 asyncResp->res.jsonValue["HidePayload"] = !ptr->payload;
421 
422                 if (ptr->payload)
423                 {
424                     const task::Payload& p = *(ptr->payload);
425                     asyncResp->res.jsonValue["Payload"]["TargetUri"] =
426                         p.targetUri;
427                     asyncResp->res.jsonValue["Payload"]["HttpOperation"] =
428                         p.httpOperation;
429                     asyncResp->res.jsonValue["Payload"]["HttpHeaders"] =
430                         p.httpHeaders;
431                     asyncResp->res.jsonValue["Payload"]["JsonBody"] =
432                         p.jsonBody.dump(
433                             -1, ' ', true,
434                             nlohmann::json::error_handler_t::replace);
435                 }
436                 asyncResp->res.jsonValue["PercentComplete"] =
437                     ptr->percentComplete;
438             });
439 }
440 
441 inline void requestRoutesTaskCollection(App& app)
442 {
443     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/")
444         .privileges(redfish::privileges::getTaskCollection)
445         .methods(boost::beast::http::verb::get)(
446             [&app](const crow::Request& req,
447                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
448                 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
449                 {
450                     return;
451                 }
452                 asyncResp->res.jsonValue["@odata.type"] =
453                     "#TaskCollection.TaskCollection";
454                 asyncResp->res.jsonValue["@odata.id"] =
455                     "/redfish/v1/TaskService/Tasks";
456                 asyncResp->res.jsonValue["Name"] = "Task Collection";
457                 asyncResp->res.jsonValue["Members@odata.count"] =
458                     task::tasks.size();
459                 nlohmann::json& members = asyncResp->res.jsonValue["Members"];
460                 members = nlohmann::json::array();
461 
462                 for (const std::shared_ptr<task::TaskData>& task : task::tasks)
463                 {
464                     if (task == nullptr)
465                     {
466                         continue; // shouldn't be possible
467                     }
468                     nlohmann::json::object_t member;
469                     member["@odata.id"] =
470                         boost::urls::format("/redfish/v1/TaskService/Tasks/{}",
471                                             std::to_string(task->index));
472                     members.emplace_back(std::move(member));
473                 }
474             });
475 }
476 
477 inline void requestRoutesTaskService(App& app)
478 {
479     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/")
480         .privileges(redfish::privileges::getTaskService)
481         .methods(boost::beast::http::verb::get)(
482             [&app](const crow::Request& req,
483                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
484                 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
485                 {
486                     return;
487                 }
488                 asyncResp->res.jsonValue["@odata.type"] =
489                     "#TaskService.v1_1_4.TaskService";
490                 asyncResp->res.jsonValue["@odata.id"] =
491                     "/redfish/v1/TaskService";
492                 asyncResp->res.jsonValue["Name"] = "Task Service";
493                 asyncResp->res.jsonValue["Id"] = "TaskService";
494                 asyncResp->res.jsonValue["DateTime"] =
495                     redfish::time_utils::getDateTimeOffsetNow().first;
496                 asyncResp->res.jsonValue["CompletedTaskOverWritePolicy"] =
497                     task_service::OverWritePolicy::Oldest;
498 
499                 asyncResp->res.jsonValue["LifeCycleEventOnTaskStateChange"] =
500                     true;
501 
502                 asyncResp->res.jsonValue["Status"]["State"] =
503                     resource::State::Enabled;
504                 asyncResp->res.jsonValue["ServiceEnabled"] = true;
505                 asyncResp->res.jsonValue["Tasks"]["@odata.id"] =
506                     "/redfish/v1/TaskService/Tasks";
507             });
508 }
509 
510 } // namespace redfish
511