* limitations under the License
*/
/*
- * @file dbus_access.cpp
+ * @file service_manager.cpp
* @author Zbigniew Jasinski <z.jasinski@samsung.com>
* @author Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
* @version 1.1
- * @brief Implementation of SystemD control class over dbus API
+ * @brief Implementation of systemd control class over dbus API
*/
#include <dpl/log/log.h>
#include <sstream>
#include <unistd.h>
-#include "dbus_access.h"
+#include <service_manager.h>
-DBusAccess::DBusAccess(const char *service_name)
+ServiceManager::ServiceManager(const char *service_name)
: m_conn(nullptr)
, m_msg(nullptr)
, m_pending(nullptr)
connectToDBus();
}
-void DBusAccess::connect() {
+void ServiceManager::connect() {
m_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &m_err);
RUNNER_ASSERT_MSG(dbus_error_is_set(&m_err) != 1,
"Error in dbus_bus_get: " << m_err.message);
dbus_connection_set_exit_on_disconnect(m_conn, FALSE);
}
-void DBusAccess::addBusMatch(const char *member) {
+void ServiceManager::addBusMatch(const char *member) {
std::ostringstream rule;
rule << "type='signal',"
<< "sender='" << m_dbus_systemd_destination << "',"
"Error in dbus_bus_add_match: " << m_err.message);
}
-void DBusAccess::subscribeSignals() {
+void ServiceManager::subscribeSignals() {
newMethodCall("Subscribe");
sendMsgWithReply();
getMsgReply();
finalizeMsgReply();
}
-void DBusAccess::reloadDbusManager() {
+void ServiceManager::reloadDbusManager() {
newMethodCall("Reload");
sendMsgWithReply();
getMsgReply();
m_runningJobs.insert(m_reloadingToken);
}
-void DBusAccess::requestName() {
+void ServiceManager::requestName() {
dbus_bus_request_name(m_conn, m_dbus_client_name.c_str(),
DBUS_NAME_FLAG_REPLACE_EXISTING , &m_err);
RUNNER_ASSERT_MSG(dbus_error_is_set(&m_err) != 1,
"Error in dbus_bus_request_name: " << m_err.message);
}
-void DBusAccess::getUnitPath() {
+void ServiceManager::getUnitPath() {
newMethodCall("GetUnit");
appendToMsg(m_service_name.c_str());
sendMsgWithReply();
m_unitPath = handleObjectPathMsgReply();
}
-void DBusAccess::newMethodCall(const char *method) {
+void ServiceManager::newMethodCall(const char *method) {
m_msg = dbus_message_new_method_call(m_dbus_systemd_destination.c_str(),
m_dbus_systemd_path.c_str(),
m_dbus_systemd_manager_interface.c_str(),
"Error in dbus_message_new_method_call");
}
-void DBusAccess::appendToMsg(const char *argument) {
+void ServiceManager::appendToMsg(const char *argument) {
DBusMessageIter iter;
dbus_message_iter_init_append(m_msg, &iter);
"Error in dbus_message_iter_append_basic");
}
-void DBusAccess::appendToMsg(const char *const *argument) {
+void ServiceManager::appendToMsg(const char *const *argument) {
DBusMessageIter iter;
DBusMessageIter subIter;
int ret;
"Error in dbus_message_iter_close_container");
}
-void DBusAccess::appendToMsg(bool argument) {
+void ServiceManager::appendToMsg(bool argument) {
DBusMessageIter iter;
dbus_message_iter_init_append(m_msg, &iter);
"Error in dbus_message_iter_append_basic");
}
-void DBusAccess::sendMsgWithReply() {
+void ServiceManager::sendMsgWithReply() {
int ret = dbus_connection_send_with_reply(m_conn, m_msg, &m_pending, -1);
RUNNER_ASSERT_MSG(ret == 1,
"Error in dbus_connection_send_with_reply");
m_msg = nullptr;
}
-void DBusAccess::getMsgReply() {
+void ServiceManager::getMsgReply() {
m_msg = dbus_pending_call_steal_reply(m_pending);
RUNNER_ASSERT_MSG(nullptr != m_msg,
"Error in dbus_pending_call_steal_reply");
}
-std::string DBusAccess::handleObjectPathMsgReply() {
+std::string ServiceManager::handleObjectPathMsgReply() {
DBusMessageIter iter;
RUNNER_ASSERT_MSG(dbus_message_iter_init(m_msg, &iter) != 0,
return ret;
}
-uint32_t DBusAccess::handleVariantUIntMsgReply() {
+uint32_t ServiceManager::handleVariantUIntMsgReply() {
DBusMessageIter iter, iter2;
RUNNER_ASSERT_MSG(dbus_message_iter_init(m_msg, &iter) != 0,
return ret;
}
-void DBusAccess::finalizeMsgReply() {
+void ServiceManager::finalizeMsgReply() {
dbus_message_unref(m_msg);
dbus_pending_call_unref(m_pending);
m_msg = nullptr;
m_pending = nullptr;
}
-void DBusAccess::connectToDBus() {
+void ServiceManager::connectToDBus() {
connect();
addBusMatch("JobRemoved");
addBusMatch("JobNew");
getUnitPath();
}
-void DBusAccess::sendToService(const char *method) {
+void ServiceManager::sendToService(const char *method) {
newMethodCall(method);
appendToMsg(m_service_name.c_str());
appendToMsg("fail");
m_runningJobs.insert(handleObjectPathMsgReply());
}
-void DBusAccess::sendMaskToService() {
+void ServiceManager::sendMaskToService() {
const char *mask[] = {m_service_name.c_str(), nullptr};
newMethodCall("MaskUnitFiles");
appendToMsg(mask);
finalizeMsgReply();
}
-void DBusAccess::sendUnmaskToService() {
+void ServiceManager::sendUnmaskToService() {
const char *mask[] = {m_service_name.c_str(), nullptr};
newMethodCall("UnmaskUnitFiles");
appendToMsg(mask);
finalizeMsgReply();
}
-uint32_t DBusAccess::getUIntProperty(const char *interface, const char *property)
+uint32_t ServiceManager::getUIntProperty(const char *interface, const char *property)
{
m_msg = dbus_message_new_method_call(m_dbus_systemd_destination.c_str(),
m_unitPath.c_str(),
return handleVariantUIntMsgReply();
}
-void DBusAccess::sendResetFailedToService() {
+void ServiceManager::sendResetFailedToService() {
newMethodCall("ResetFailedUnit");
appendToMsg(m_service_name.c_str());
sendMsgWithReply();
finalizeMsgReply();
}
-DBusHandlerResult DBusAccess::messageHandler(DBusConnection *conn, DBusMessage *msg, void *t) {
+DBusHandlerResult ServiceManager::messageHandler(DBusConnection *conn, DBusMessage *msg, void *t) {
(void) conn;
- DBusAccess* self = reinterpret_cast<DBusAccess*>(t);
+ ServiceManager* self = reinterpret_cast<ServiceManager*>(t);
if (self->isSignal(msg, "JobRemoved"))
self->signalJobRemovedHandler(msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
-bool DBusAccess::isSignal(DBusMessage *msg, const char *signal) {
+bool ServiceManager::isSignal(DBusMessage *msg, const char *signal) {
return dbus_message_is_signal(msg, m_dbus_systemd_manager_interface.c_str(), signal);
}
-void DBusAccess::signalJobRemovedHandler(DBusMessage *msg) {
+void ServiceManager::signalJobRemovedHandler(DBusMessage *msg) {
DBusMessageIter iter;
RUNNER_ASSERT_MSG(dbus_message_iter_init(msg, &iter) != 0,
"Message has no arguments");
}
}
-void DBusAccess::signalJobNewHandler(DBusMessage *msg) {
+void ServiceManager::signalJobNewHandler(DBusMessage *msg) {
DBusMessageIter iter;
RUNNER_ASSERT_MSG(dbus_message_iter_init(msg, &iter) != 0,
"Message has no arguments");
m_runningJobs.insert(path);
}
-void DBusAccess::signalReloadingHandler(DBusMessage *msg) {
+void ServiceManager::signalReloadingHandler(DBusMessage *msg) {
DBusMessageIter iter;
RUNNER_ASSERT_MSG(dbus_message_iter_init(msg, &iter) != 0,
"Message has no arguments");
m_runningJobs.erase(m_reloadingToken);
}
-void DBusAccess::waitForRunningJobsFinish() {
+void ServiceManager::waitForRunningJobsFinish() {
while (!m_runningJobs.empty())
dbus_connection_read_write_dispatch(m_conn, -1);
}
-void DBusAccess::startService() {
+void ServiceManager::startService() {
sendToService("StartUnit");
waitForRunningJobsFinish();
sendResetFailedToService();
}
-void DBusAccess::stopService() {
+void ServiceManager::stopService() {
sendToService("StopUnit");
waitForRunningJobsFinish();
sendResetFailedToService();
}
-void DBusAccess::restartService() {
+void ServiceManager::restartService() {
sendToService("RestartUnit");
waitForRunningJobsFinish();
sendResetFailedToService();
}
-pid_t DBusAccess::getServicePid() {
+pid_t ServiceManager::getServicePid() {
return static_cast<pid_t>(getUIntProperty(m_dbus_systemd_service_interface.c_str(), "MainPID"));
}
-void DBusAccess::maskService() {
+void ServiceManager::maskService() {
sendMaskToService();
reloadDbusManager();
waitForRunningJobsFinish();
sendResetFailedToService();
}
-void DBusAccess::unmaskService() {
+void ServiceManager::unmaskService() {
sendUnmaskToService();
reloadDbusManager();
waitForRunningJobsFinish();
sendResetFailedToService();
}
-DBusAccess::~DBusAccess() {
+ServiceManager::~ServiceManager() {
dbus_connection_close(m_conn);
if (m_conn)
dbus_connection_unref(m_conn);