blob: 04d41caa30588cfdf228fac4d4951a7018c1a10b [file] [log] [blame]
/*
// Copyright (c) 2018 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 <fstream>
#include <regex>
#include "srvcfg_manager.hpp"
extern std::shared_ptr<boost::asio::deadline_timer> timer;
extern std::map<std::string, std::shared_ptr<phosphor::service::ServiceConfig>>
srvMgrObjects;
namespace phosphor
{
namespace service
{
static constexpr const char *overrideConfFileName = "override.conf";
static constexpr const size_t restartTimeout = 15; // seconds
static constexpr const char *systemd1UnitBasePath =
"/org/freedesktop/systemd1/unit/";
static constexpr const char *systemdOverrideUnitBasePath =
"/etc/systemd/system/";
void ServiceConfig::syncWithSystemD1Properties()
{
// Read systemd1 socket/service property and load.
conn->async_method_call(
[this](boost::system::error_code ec,
const sdbusplus::message::variant<
std::vector<std::tuple<std::string, std::string>>> &value) {
if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async_method_call error: Failed to get property");
return;
}
try
{
auto listenVal = sdbusplus::message::variant_ns::get<
std::vector<std::tuple<std::string, std::string>>>(value);
protocol = std::get<0>(listenVal[0]);
std::string port = std::get<1>(listenVal[0]);
auto tmp = std::stoul(port.substr(port.find_last_of(":") + 1),
nullptr, 10);
if (tmp > std::numeric_limits<uint16_t>::max())
{
throw std::out_of_range("Out of range");
}
portNum = tmp;
}
catch (const std::exception &e)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Exception for port number",
phosphor::logging::entry("WHAT=%s", e.what()));
return;
}
conn->async_method_call(
[](boost::system::error_code ec) {
if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async_method_call error: Failed to set property");
return;
}
},
serviceConfigSrvName, objPath.c_str(),
"org.freedesktop.DBus.Properties", "Set", serviceConfigIntfName,
"Port", sdbusplus::message::variant<uint16_t>(portNum));
},
"org.freedesktop.systemd1", sysDSockObjPath.c_str(),
"org.freedesktop.DBus.Properties", "Get",
"org.freedesktop.systemd1.Socket", "Listen");
conn->async_method_call(
[this](boost::system::error_code ec,
const sdbusplus::message::variant<std::string> &pValue) {
if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async_method_call error: Failed to get property");
return;
}
channelList.clear();
std::istringstream stm(
sdbusplus::message::variant_ns::get<std::string>(pValue));
std::string token;
while (std::getline(stm, token, ','))
{
channelList.push_back(token);
}
conn->async_method_call(
[](boost::system::error_code ec) {
if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async_method_call error: Failed to set property");
return;
}
},
serviceConfigSrvName, objPath.c_str(),
"org.freedesktop.DBus.Properties", "Set", serviceConfigIntfName,
"Channel",
sdbusplus::message::variant<std::vector<std::string>>(
channelList));
},
"org.freedesktop.systemd1", sysDSockObjPath.c_str(),
"org.freedesktop.DBus.Properties", "Get",
"org.freedesktop.systemd1.Socket", "BindToDevice");
std::string srvUnitName(sysDUnitName);
if (srvUnitName == "dropbear")
{
srvUnitName.append("@");
}
srvUnitName.append(".service");
conn->async_method_call(
[this](boost::system::error_code ec, const std::string &pValue) {
if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async_method_call error: Failed to get property");
return;
}
stateValue = pValue;
conn->async_method_call(
[](boost::system::error_code ec) {
if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async_method_call error: Failed to set property");
return;
}
},
serviceConfigSrvName, objPath.c_str(),
"org.freedesktop.DBus.Properties", "Set", serviceConfigIntfName,
"State", sdbusplus::message::variant<std::string>(stateValue));
},
"org.freedesktop.systemd1", "/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager", "GetUnitFileState", srvUnitName);
return;
}
ServiceConfig::ServiceConfig(
sdbusplus::asio::object_server &srv_,
std::shared_ptr<sdbusplus::asio::connection> &conn_, std::string objPath_,
std::string unitName) :
server(srv_),
conn(conn_), objPath(objPath_), sysDUnitName(unitName)
{
std::string socketUnitName(sysDUnitName + ".socket");
// .socket systemd service files are handled.
// Regular .service only files are ignored.
if (!checkSystemdUnitExist(socketUnitName))
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Unit doesn't exist.",
phosphor::logging::entry("UNITNAME=%s", socketUnitName.c_str()));
phosphor::logging::elog<
sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure>();
}
/// Check override socket directory exist, if not create it.
std::experimental::filesystem::path ovrUnitFileDir(
systemdOverrideUnitBasePath);
ovrUnitFileDir += socketUnitName;
ovrUnitFileDir += ".d";
if (!std::experimental::filesystem::exists(ovrUnitFileDir))
{
if (!std::experimental::filesystem::create_directories(ovrUnitFileDir))
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Unable to create the directory.",
phosphor::logging::entry("DIR=%s", ovrUnitFileDir.c_str()));
phosphor::logging::elog<sdbusplus::xyz::openbmc_project::Common::
Error::InternalFailure>();
}
}
/* Store require info locally */
unitSocketFilePath = std::string(ovrUnitFileDir);
sysDSockObjPath = systemd1UnitBasePath;
sysDSockObjPath.append(
std::regex_replace(sysDUnitName, std::regex("-"), "_2d"));
sysDSockObjPath.append("_2esocket");
// Adds interface, object and Properties....
registerProperties();
syncWithSystemD1Properties();
updatedFlag = 0;
return;
}
void ServiceConfig::applySystemDServiceConfig()
{
phosphor::logging::log<phosphor::logging::level::INFO>(
"Applying new settings.",
phosphor::logging::entry("OBJPATH=%s", objPath.c_str()));
if (updatedFlag & ((1 << static_cast<uint8_t>(UpdatedProp::channel)) |
(1 << static_cast<uint8_t>(UpdatedProp::port))))
{
// Create override config file and write data.
std::string ovrCfgFile{unitSocketFilePath + "/" + overrideConfFileName};
std::string tmpFile{ovrCfgFile + "_tmp"};
std::ofstream cfgFile(tmpFile, std::ios::out);
if (!cfgFile.good())
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Failed to open override.conf_tmp file");
phosphor::logging::elog<sdbusplus::xyz::openbmc_project::Common::
Error::InternalFailure>();
}
// Write the socket header
cfgFile << "[Socket]\n";
// Listen
cfgFile << "Listen" << protocol << "="
<< "\n";
cfgFile << "Listen" << protocol << "=" << portNum << "\n";
// BindToDevice
bool firstElement = true;
cfgFile << "BindToDevice=";
for (const auto &it : channelList)
{
if (firstElement)
{
cfgFile << it;
firstElement = false;
}
else
{
cfgFile << "," << it;
}
}
cfgFile.close();
if (std::rename(tmpFile.c_str(), ovrCfgFile.c_str()) != 0)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Failed to rename tmp file as override.conf");
std::remove(tmpFile.c_str());
phosphor::logging::elog<sdbusplus::xyz::openbmc_project::Common::
Error::InternalFailure>();
}
// Systemd forcing explicit socket stop before reload...!
std::string socketUnitName(sysDUnitName + ".socket");
systemdUnitAction(conn, socketUnitName, sysdActionStopUnit);
std::string srvUnitName(sysDUnitName + ".service");
systemdUnitAction(conn, srvUnitName, sysdActionStopUnit);
// Perform daemon reload to read new settings
systemdDaemonReload(conn);
// Restart the unit
systemdUnitAction(conn, socketUnitName, sysdActionStartUnit);
systemdUnitAction(conn, srvUnitName, sysdActionStartUnit);
}
if (updatedFlag & (1 << static_cast<uint8_t>(UpdatedProp::state)))
{
if ((stateValue == "enabled") || (stateValue == "disabled"))
{
systemdUnitFileStateChange(conn, sysDUnitName, stateValue);
}
}
// Reset the flag
updatedFlag = 0;
// All done. Lets reload the properties which are applied on systemd1.
// TODO: We need to capture the service restart signal and reload data
// inside the signal handler. So that we can update the service properties
// modified, outside of this service as well.
syncWithSystemD1Properties();
return;
}
void ServiceConfig::startServiceRestartTimer()
{
timer->expires_from_now(boost::posix_time::seconds(restartTimeout));
timer->async_wait([this](const boost::system::error_code &ec) {
if (ec == boost::asio::error::operation_aborted)
{
// Timer reset.
return;
}
else if (ec)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"async wait error.");
return;
}
for (auto &srvMgrObj : srvMgrObjects)
{
auto &srvObj = srvMgrObj.second;
if (srvObj->updatedFlag)
{
srvObj->applySystemDServiceConfig();
}
}
});
}
void ServiceConfig::registerProperties()
{
std::shared_ptr<sdbusplus::asio::dbus_interface> iface =
server.add_interface(objPath, serviceConfigIntfName);
iface->register_property(
"Port", portNum, [this](const uint16_t &req, uint16_t &res) {
phosphor::logging::log<phosphor::logging::level::ERR>(
" Inside register_property");
if (req == res)
{
return 1;
}
portNum = req;
updatedFlag |= (1 << static_cast<uint8_t>(UpdatedProp::port));
startServiceRestartTimer();
res = req;
return 1;
});
iface->register_property(
"Channel", channelList,
[this](const std::vector<std::string> &req,
std::vector<std::string> &res) {
if (req == res)
{
return 1;
}
channelList.clear();
std::copy(req.begin(), req.end(), back_inserter(channelList));
updatedFlag |= (1 << static_cast<uint8_t>(UpdatedProp::channel));
startServiceRestartTimer();
res = req;
return 1;
});
iface->register_property(
"State", stateValue, [this](const std::string &req, std::string &res) {
if (req == res)
{
return 1;
}
if ((req != "enabled") && (req != "disabled") && (req != "static"))
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Invalid value specified");
return -EINVAL;
}
stateValue = req;
updatedFlag |= (1 << static_cast<uint8_t>(UpdatedProp::state));
startServiceRestartTimer();
res = req;
return 1;
});
iface->initialize();
return;
}
} // namespace service
} // namespace phosphor