blob: fb2d0be76a0c489222cd0a015d2c3f14b853b1f7 [file] [log] [blame]
/*
// 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.
*/
#pragma once
#include "node.hpp"
#include <boost/asio.hpp>
#include <boost/container/flat_map.hpp>
#include <task_messages.hpp>
#include <chrono>
#include <variant>
namespace redfish
{
namespace task
{
constexpr size_t maxTaskCount = 100; // arbitrary limit
static std::deque<std::shared_ptr<struct TaskData>> tasks;
constexpr bool completed = true;
struct Payload
{
Payload(const crow::Request& req) :
targetUri(req.url), 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};
jsonBody = nlohmann::json::parse(req.body, nullptr, false);
if (jsonBody.is_discarded())
{
jsonBody = nullptr;
}
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;
};
inline void to_json(nlohmann::json& j, const Payload& p)
{
j = {{"TargetUri", p.targetUri},
{"HttpOperation", p.httpOperation},
{"HttpHeaders", p.httpHeaders},
{"JsonBody", p.jsonBody.dump()}};
}
struct TaskData : std::enable_shared_from_this<TaskData>
{
private:
TaskData(std::function<bool(boost::system::error_code,
sdbusplus::message::message&,
const std::shared_ptr<TaskData>&)>&& handler,
const std::string& match, size_t idx) :
callback(std::move(handler)),
matchStr(match), index(idx),
startTime(std::chrono::system_clock::to_time_t(
std::chrono::system_clock::now())),
status("OK"), state("Running"), messages(nlohmann::json::array()),
timer(crow::connections::systemBus->get_io_context())
{}
TaskData() = delete;
public:
static std::shared_ptr<TaskData>& createTask(
std::function<bool(boost::system::error_code,
sdbusplus::message::message&,
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::message&,
const std::shared_ptr<TaskData>&)>&& handler,
const std::string& match, size_t idx) :
TaskData(std::move(handler), match, idx)
{}
};
if (tasks.size() >= maxTaskCount)
{
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},
{"@odata.type", "#Task.v1_4_3.Task"},
{"Id", strIdx},
{"TaskState", state},
{"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 (!gave204)
{
res.result(boost::beast::http::status::no_content);
gave204 = true;
}
}
void finishTask(void)
{
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::message msg;
self->finishTask();
self->state = "Cancelled";
self->status = "Warning";
self->messages.emplace_back(
messages::taskAborted(std::to_string(self->index)));
self->callback(ec, msg, self);
});
}
void startTimer(const std::chrono::seconds& timeout)
{
if (match)
{
return;
}
match = std::make_unique<sdbusplus::bus::match::match>(
static_cast<sdbusplus::bus::bus&>(*crow::connections::systemBus),
matchStr,
[self = shared_from_this()](sdbusplus::message::message& 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->timer.cancel();
self->finishTask();
// reset the match after the callback was successful
boost::asio::post(
crow::connections::systemBus->get_io_context(),
[self] { self->match.reset(); });
return;
}
});
extendTimer(timeout);
messages.emplace_back(messages::taskStarted(std::to_string(index)));
}
std::function<bool(boost::system::error_code, sdbusplus::message::message&,
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::match> match;
std::optional<time_t> endTime;
std::optional<Payload> payload;
bool gave204 = false;
};
} // namespace task
class TaskMonitor : public Node
{
public:
TaskMonitor(CrowApp& app) :
Node((app), "/redfish/v1/TaskService/Tasks/<str>/Monitor/",
std::string())
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
void doGet(crow::Response& res, const crow::Request& req,
const std::vector<std::string>& params) override
{
auto asyncResp = std::make_shared<AsyncResp>(res);
if (params.size() != 1)
{
messages::internalError(asyncResp->res);
return;
}
const std::string& strParam = params[0];
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, "Monitor", strParam);
return;
}
std::shared_ptr<task::TaskData>& ptr = *find;
// monitor expires after 204
if (ptr->gave204)
{
messages::resourceNotFound(asyncResp->res, "Monitor", strParam);
return;
}
ptr->populateResp(asyncResp->res);
}
};
class Task : public Node
{
public:
Task(CrowApp& app) :
Node((app), "/redfish/v1/TaskService/Tasks/<str>/", std::string())
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
void doGet(crow::Response& res, const crow::Request& req,
const std::vector<std::string>& params) override
{
auto asyncResp = std::make_shared<AsyncResp>(res);
if (params.size() != 1)
{
messages::internalError(asyncResp->res);
return;
}
const std::string& strParam = params[0];
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, "Tasks", strParam);
return;
}
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"] =
crow::utility::getDateTime(ptr->startTime);
if (ptr->endTime)
{
asyncResp->res.jsonValue["EndTime"] =
crow::utility::getDateTime(*(ptr->endTime));
}
asyncResp->res.jsonValue["TaskStatus"] = ptr->status;
asyncResp->res.jsonValue["Messages"] = ptr->messages;
asyncResp->res.jsonValue["@odata.id"] =
"/redfish/v1/TaskService/Tasks/" + strParam;
if (!ptr->gave204)
{
asyncResp->res.jsonValue["TaskMonitor"] =
"/redfish/v1/TaskService/Tasks/" + strParam + "/Monitor";
}
if (ptr->payload)
{
asyncResp->res.jsonValue["Payload"] = *(ptr->payload);
}
}
};
class TaskCollection : public Node
{
public:
TaskCollection(CrowApp& app) : Node(app, "/redfish/v1/TaskService/Tasks/")
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
void doGet(crow::Response& res, const crow::Request& req,
const std::vector<std::string>& params) override
{
auto asyncResp = std::make_shared<AsyncResp>(res);
asyncResp->res.jsonValue["@odata.type"] =
"#TaskCollection.TaskCollection";
asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/TaskService/Tasks";
asyncResp->res.jsonValue["Name"] = "Task Collection";
asyncResp->res.jsonValue["Members@odata.count"] = task::tasks.size();
nlohmann::json& members = asyncResp->res.jsonValue["Members"];
members = nlohmann::json::array();
for (const std::shared_ptr<task::TaskData>& task : task::tasks)
{
if (task == nullptr)
{
continue; // shouldn't be possible
}
members.emplace_back(
nlohmann::json{{"@odata.id", "/redfish/v1/TaskService/Tasks/" +
std::to_string(task->index)}});
}
}
};
class TaskService : public Node
{
public:
TaskService(CrowApp& app) : Node(app, "/redfish/v1/TaskService/")
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
void doGet(crow::Response& res, const crow::Request& req,
const std::vector<std::string>& params) override
{
auto asyncResp = std::make_shared<AsyncResp>(res);
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"] = crow::utility::dateTimeNow();
asyncResp->res.jsonValue["CompletedTaskOverWritePolicy"] = "Oldest";
// todo: if we enable events, change this to true
asyncResp->res.jsonValue["LifeCycleEventOnTaskStateChange"] = false;
auto health = std::make_shared<HealthPopulate>(asyncResp);
health->populate();
asyncResp->res.jsonValue["Status"]["State"] = "Enabled";
asyncResp->res.jsonValue["ServiceEnabled"] = true;
asyncResp->res.jsonValue["Tasks"] = {
{"@odata.id", "/redfish/v1/TaskService/Tasks"}};
}
};
} // namespace redfish