| #ifndef THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TASK_H_ |
| #define THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TASK_H_ |
| |
| /* |
| // Copyright (c) 2020 Intel Corporation |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| */ |
| |
| #include <algorithm> |
| #include <array> |
| #include <chrono> // NOLINT |
| #include <cstddef> |
| #include <ctime> |
| #include <deque> |
| #include <functional> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <string_view> |
| #include <utility> |
| |
| #include "boost/asio/post.hpp" // NOLINT |
| #include "boost/asio/steady_timer.hpp" // NOLINT |
| #include "app.hpp" |
| #include "http_request.hpp" |
| #include "http_response.hpp" |
| #include "logging.hpp" |
| #include "parsing.hpp" |
| #include "utility.hpp" |
| #include "async_resp.hpp" |
| #include "error_messages.hpp" |
| #include "event_service_manager.hpp" |
| #include "query.hpp" |
| #include "registries/privilege_registry.hpp" |
| #include "task_messages.hpp" |
| #include "time_utils.hpp" |
| #include "health.hpp" |
| #include <nlohmann/json.hpp> |
| #include "managed_store.hpp" |
| #include "sdbusplus/bus.hpp" |
| #include "sdbusplus/bus/match.hpp" |
| #include "sdbusplus/message.hpp" |
| |
| #ifdef UNIT_TEST_BUILD |
| #include "test/g3/mock_managed_store.hpp" // NOLINT |
| #endif |
| |
| namespace redfish { |
| |
| namespace task { |
| constexpr size_t maxTaskCount = 100; // arbitrary limit |
| |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| static std::deque<std::shared_ptr<struct TaskData>> tasks; |
| |
| constexpr bool completed = true; |
| |
| struct Payload { |
| explicit Payload(const crow::Request& req) |
| : targetUri(req.url().encoded_path()), |
| httpOperation(req.methodString()), |
| httpHeaders(nlohmann::json::array()) { |
| using field_ns = boost::beast::http::field; |
| constexpr const std::array<boost::beast::http::field, 7> headerWhitelist = { |
| field_ns::accept, field_ns::accept_encoding, field_ns::user_agent, |
| field_ns::host, field_ns::connection, field_ns::content_length, |
| field_ns::upgrade}; |
| |
| JsonParseResult ret = parseRequestAsJson(req, jsonBody); |
| if (ret != JsonParseResult::Success) { |
| return; |
| } |
| |
| for (const auto& field : req.fields()) { |
| if (std::find(headerWhitelist.begin(), headerWhitelist.end(), |
| field.name()) == headerWhitelist.end()) { |
| continue; |
| } |
| std::string header; |
| header.reserve(field.name_string().size() + 2 + field.value().size()); |
| header += field.name_string(); |
| header += ": "; |
| header += field.value(); |
| httpHeaders.emplace_back(std::move(header)); |
| } |
| } |
| Payload() = delete; |
| |
| std::string targetUri; |
| std::string httpOperation; |
| nlohmann::json httpHeaders; |
| nlohmann::json jsonBody; |
| }; |
| |
| struct TaskData : std::enable_shared_from_this<TaskData> { |
| private: |
| TaskData(std::function<bool(boost::system::error_code, sdbusplus::message_t&, |
| const std::shared_ptr<TaskData>&)>&& handler, |
| const std::string& matchIn, size_t idx) |
| : callback(std::move(handler)), |
| matchStr(matchIn), |
| index(idx), |
| startTime(std::chrono::system_clock::to_time_t( |
| std::chrono::system_clock::now())), |
| status("OK"), |
| state("Running"), |
| messages(nlohmann::json::array()), |
| timer(managedStore::GetManagedObjectStore()->GetIoContext()) |
| |
| {} |
| |
| public: |
| TaskData() = delete; |
| |
| static std::shared_ptr<TaskData>& createTask( |
| std::function<bool(boost::system::error_code, sdbusplus::message_t&, |
| const std::shared_ptr<TaskData>&)>&& handler, |
| const std::string& match) { |
| static size_t lastTask = 0; |
| struct MakeSharedHelper : public TaskData { |
| MakeSharedHelper( |
| std::function<bool(boost::system::error_code, sdbusplus::message_t&, |
| const std::shared_ptr<TaskData>&)>&& handler, |
| const std::string& match2, size_t idx) |
| : TaskData(std::move(handler), match2, idx) {} |
| }; |
| |
| if (tasks.size() >= maxTaskCount) { |
| const auto& last = tasks.front(); |
| |
| // destroy all references |
| last->timer.cancel(); |
| last->match.reset(); |
| tasks.pop_front(); |
| } |
| |
| return tasks.emplace_back(std::make_shared<MakeSharedHelper>( |
| std::move(handler), match, lastTask++)); |
| } |
| |
| void populateResp(crow::Response& res, size_t retryAfterSeconds = 30) { |
| if (!endTime) { |
| res.result(boost::beast::http::status::accepted); |
| std::string strIdx = std::to_string(index); |
| std::string uri = "/redfish/v1/TaskService/Tasks/" + strIdx; |
| |
| res.jsonValue["@odata.id"] = uri; |
| res.jsonValue["@odata.type"] = "#Task.v1_4_3.Task"; |
| res.jsonValue["Id"] = strIdx; |
| res.jsonValue["TaskState"] = state; |
| res.jsonValue["TaskStatus"] = status; |
| |
| res.addHeader(boost::beast::http::field::location, uri + "/Monitor"); |
| res.addHeader(boost::beast::http::field::retry_after, |
| std::to_string(retryAfterSeconds)); |
| } else if (!gaveResult) { |
| if (result) { |
| res.jsonValue = *result; |
| } |
| res.result(resultHttpStatus); |
| gaveResult = true; |
| } |
| } |
| |
| void finishTask() { |
| endTime = |
| std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); |
| } |
| |
| void extendTimer(const std::chrono::seconds& timeout) { |
| timer.expires_after(timeout); |
| timer.async_wait([self = shared_from_this()](boost::system::error_code ec) { |
| if (ec == boost::asio::error::operation_aborted) { |
| return; // completed successfully |
| } |
| if (!ec) { |
| // change ec to error as timer expired |
| ec = boost::asio::error::operation_aborted; |
| } |
| self->match.reset(); |
| sdbusplus::message_t msg; |
| self->finishTask(); |
| self->state = "Cancelled"; |
| self->status = "Warning"; |
| self->messages.emplace_back( |
| messages::taskAborted(std::to_string(self->index))); |
| // Send event :TaskAborted |
| self->sendTaskEvent(self->state, self->index); |
| self->callback(ec, msg, self); |
| }); |
| } |
| |
| static void sendTaskEvent(std::string_view state, size_t index) { |
| std::string origin = |
| "/redfish/v1/TaskService/Tasks/" + std::to_string(index); |
| std::string resType = "Task"; |
| // TaskState enums which should send out an event are: |
| // "Starting" = taskResumed |
| // "Running" = taskStarted |
| // "Suspended" = taskPaused |
| // "Interrupted" = taskPaused |
| // "Pending" = taskPaused |
| // "Stopping" = taskAborted |
| // "Completed" = taskCompletedOK |
| // "Killed" = taskRemoved |
| // "Exception" = taskCompletedWarning |
| // "Cancelled" = taskCancelled |
| if (state == "Starting") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskResumed(std::to_string(index)), origin, |
| resType); |
| } else if (state == "Running") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskStarted(std::to_string(index)), origin, |
| resType); |
| } else if ((state == "Suspended") || (state == "Interrupted") || |
| (state == "Pending")) { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskPaused(std::to_string(index)), origin, |
| resType); |
| } else if (state == "Stopping") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskAborted(std::to_string(index)), origin, |
| resType); |
| } else if (state == "Completed") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskCompletedOK(std::to_string(index)), origin, |
| resType); |
| } else if (state == "Killed") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskRemoved(std::to_string(index)), origin, |
| resType); |
| } else if (state == "Exception") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskCompletedWarning(std::to_string(index)), |
| origin, resType); |
| } else if (state == "Cancelled") { |
| redfish::EventServiceManager::getInstance().sendEvent( |
| redfish::messages::taskCancelled(std::to_string(index)), origin, |
| resType); |
| } else { |
| BMCWEB_LOG_INFO << "sendTaskEvent: No events to send"; |
| } |
| } |
| |
| // Can be called manually by task handlers implementing asynchronous |
| // completion. They must also call stopMonitor(). |
| void complete() { |
| timer.cancel(); |
| finishTask(); |
| |
| // Send event |
| sendTaskEvent(state, index); |
| } |
| |
| void complete(nlohmann::json&& outputResult, |
| boost::beast::http::status httpStatus) { |
| result = std::move(outputResult); |
| resultHttpStatus = httpStatus; |
| complete(); |
| } |
| |
| // Stop watching for property changes. Only required to be called by users |
| // when handling calling complete() manually too. |
| void stopMonitor() { |
| boost::asio::post(managedStore::GetManagedObjectStore()->GetIoContext(), |
| [self = shared_from_this()] { self->match.reset(); }); |
| } |
| |
| void startTimer(const std::chrono::seconds& timeout) { |
| if (match) { |
| return; |
| } |
| match = std::make_unique<sdbusplus::bus::match_t>( |
| static_cast<sdbusplus::bus_t&>( |
| *(managedStore::GetManagedObjectStore() |
| ->GetDeprecatedThreadUnsafeSystemBus())), |
| matchStr, [self = shared_from_this()](sdbusplus::message_t& message) { |
| boost::system::error_code ec; |
| |
| // callback to return True if callback is done, callback needs |
| // to update status itself if needed |
| if (self->callback(ec, message, self) == task::completed) { |
| self->complete(); |
| self->stopMonitor(); |
| } |
| }); |
| |
| extendTimer(timeout); |
| messages.emplace_back(messages::taskStarted(std::to_string(index))); |
| // Send event : TaskStarted |
| sendTaskEvent(state, index); |
| } |
| |
| std::function<bool(boost::system::error_code, sdbusplus::message_t&, |
| const std::shared_ptr<TaskData>&)> |
| callback; |
| std::string matchStr; |
| size_t index; |
| time_t startTime; |
| std::string status; |
| std::string state; |
| nlohmann::json messages; |
| boost::asio::steady_timer timer; |
| std::unique_ptr<sdbusplus::bus::match_t> match; |
| std::optional<time_t> endTime; |
| std::optional<Payload> payload; |
| std::optional<nlohmann::json> result; |
| boost::beast::http::status resultHttpStatus = |
| boost::beast::http::status::no_content; |
| bool gaveResult = false; |
| int percentComplete = 0; |
| }; |
| |
| } // namespace task |
| |
| inline void handleGetTaskMonitor( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& strParam) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| auto find = |
| std::find_if(task::tasks.begin(), task::tasks.end(), |
| [&strParam](const std::shared_ptr<task::TaskData>& task) { |
| if (!task) { |
| return false; |
| } |
| |
| // we compare against the string version as on failure |
| // strtoul returns 0 |
| return std::to_string(task->index) == strParam; |
| }); |
| |
| if (find == task::tasks.end()) { |
| messages::resourceNotFound(asyncResp->res, "Task", strParam); |
| return; |
| } |
| std::shared_ptr<task::TaskData>& ptr = *find; |
| // monitor expires after result |
| if (ptr->gaveResult) { |
| messages::resourceNotFound(asyncResp->res, "Task", strParam); |
| return; |
| } |
| ptr->populateResp(asyncResp->res); |
| } |
| |
| inline void requestRoutesTaskMonitor(App& app) { |
| BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/<str>/Monitor/") |
| .privileges(redfish::privileges::getTask) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGetTaskMonitor, std::ref(app))); |
| } |
| |
| inline void handleGetTask(App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& strParam) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| auto find = |
| std::find_if(task::tasks.begin(), task::tasks.end(), |
| [&strParam](const std::shared_ptr<task::TaskData>& task) { |
| if (!task) { |
| return false; |
| } |
| |
| // we compare against the string version as on failure |
| // strtoul returns 0 |
| return std::to_string(task->index) == strParam; |
| }); |
| |
| if (find == task::tasks.end()) { |
| messages::resourceNotFound(asyncResp->res, "Task", strParam); |
| return; |
| } |
| |
| const std::shared_ptr<task::TaskData>& ptr = *find; |
| |
| asyncResp->res.jsonValue["@odata.type"] = "#Task.v1_4_3.Task"; |
| asyncResp->res.jsonValue["Id"] = strParam; |
| asyncResp->res.jsonValue["Name"] = "Task " + strParam; |
| asyncResp->res.jsonValue["TaskState"] = ptr->state; |
| asyncResp->res.jsonValue["StartTime"] = |
| redfish::time_utils::getDateTimeStdtime(ptr->startTime); |
| if (ptr->endTime) { |
| asyncResp->res.jsonValue["EndTime"] = |
| redfish::time_utils::getDateTimeStdtime(*(ptr->endTime)); |
| } |
| asyncResp->res.jsonValue["TaskStatus"] = ptr->status; |
| asyncResp->res.jsonValue["Messages"] = ptr->messages; |
| asyncResp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces( |
| "redfish", "v1", "TaskService", "Tasks", strParam); |
| if (!ptr->gaveResult) { |
| asyncResp->res.jsonValue["TaskMonitor"] = |
| "/redfish/v1/TaskService/Tasks/" + strParam + "/Monitor"; |
| } |
| if (ptr->payload) { |
| const task::Payload& p = *(ptr->payload); |
| asyncResp->res.jsonValue["Payload"]["TargetUri"] = p.targetUri; |
| asyncResp->res.jsonValue["Payload"]["HttpOperation"] = p.httpOperation; |
| asyncResp->res.jsonValue["Payload"]["HttpHeaders"] = p.httpHeaders; |
| asyncResp->res.jsonValue["Payload"]["JsonBody"] = |
| p.jsonBody.dump(2, ' ', true, nlohmann::json::error_handler_t::replace); |
| } |
| asyncResp->res.jsonValue["PercentComplete"] = ptr->percentComplete; |
| } |
| |
| inline void requestRoutesTask(App& app) { |
| BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/<str>/") |
| .privileges(redfish::privileges::getTask) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGetTask, std::ref(app))); |
| } |
| |
| inline void handleGetTaskCollection( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = "#TaskCollection.TaskCollection"; |
| asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/TaskService/Tasks"; |
| asyncResp->res.jsonValue["Name"] = "Task Collection"; |
| nlohmann::json& members = asyncResp->res.jsonValue["Members"]; |
| if (!members.is_array()) { |
| // With Redfish aggregation, top level collections can have their |
| // Members array already created if a satellite response has been |
| // processed first. In that case we don't want to clobber the |
| // aggregated data |
| members = nlohmann::json::array(); |
| } |
| |
| for (const std::shared_ptr<task::TaskData>& task : task::tasks) { |
| if (task == nullptr) { |
| continue; // shouldn't be possible |
| } |
| nlohmann::json::object_t member; |
| member["@odata.id"] = crow::utility::urlFromPieces( |
| "redfish", "v1", "TaskService", "Tasks", std::to_string(task->index)); |
| members.emplace_back(std::move(member)); |
| } |
| asyncResp->res.jsonValue["Members@odata.count"] = members.size(); |
| } |
| |
| inline void requestRoutesTaskCollection(App& app) { |
| BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/") |
| .privileges(redfish::privileges::getTaskCollection) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGetTaskCollection, std::ref(app))); |
| } |
| |
| inline void handleGetTaskService( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = "#TaskService.v1_1_4.TaskService"; |
| asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/TaskService"; |
| asyncResp->res.jsonValue["Name"] = "Task Service"; |
| asyncResp->res.jsonValue["Id"] = "TaskService"; |
| asyncResp->res.jsonValue["DateTime"] = |
| redfish::time_utils::getDateTimeOffsetNow().first; |
| asyncResp->res.jsonValue["CompletedTaskOverWritePolicy"] = "Oldest"; |
| |
| asyncResp->res.jsonValue["LifeCycleEventOnTaskStateChange"] = true; |
| |
| #ifdef HEALTH_POPULATE |
| auto health = std::make_shared<HealthPopulate>(asyncResp); |
| health->populate(); |
| #endif |
| asyncResp->res.jsonValue["Status"]["State"] = "Enabled"; |
| asyncResp->res.jsonValue["ServiceEnabled"] = true; |
| asyncResp->res.jsonValue["Tasks"]["@odata.id"] = |
| "/redfish/v1/TaskService/Tasks"; |
| } |
| |
| inline void requestRoutesTaskService(App& app) { |
| BMCWEB_ROUTE(app, "/redfish/v1/TaskService/") |
| .privileges(redfish::privileges::getTaskService) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGetTaskService, std::ref(app))); |
| } |
| |
| } // namespace redfish |
| |
| #endif // THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TASK_H_ |
