GLIB_DEPS
BUNDLE_DEPS
Boost
+ PKGMGR_DEPS
PKGMGR_INFO_DEPS
+ PKGMGR_INSTALLER_DEPS
TZPLATFORM_DEPS
)
#ifndef ERROR_TYPE_HH_
#define ERROR_TYPE_HH_
+#include <pkgmgr_installer_error.h>
+
namespace res_handler {
enum ErrorType {
- ERROR_NONE = 0,
- ERROR_INVALID_PARAMETER,
- ERROR_PKG_NOT_FOUND,
- ERROR_PERMISSION_DENIED,
- ERROR_SYSTEM_ERROR,
- ERROR_RES_NOT_FOUND,
- ERROR_OUT_OF_SPACE,
- ERROR_OUT_OF_MEMORY
+ ERROR_NONE = PKGMGR_INSTALLER_ERRCODE_OK,
+ ERROR_INVALID_PARAMETER = PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE,
+ ERROR_PKG_NOT_FOUND = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND,
+ ERROR_PERMISSION_DENIED = PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR,
+ ERROR_SYSTEM_ERROR = PKGMGR_INSTALLER_ERRCODE_ERROR,
+ ERROR_RES_NOT_FOUND = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND,
+ ERROR_OUT_OF_SPACE = PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE,
+ ERROR_OUT_OF_MEMORY = PKGMGR_INSTALLER_ERRCODE_ERROR
};
} // namespace res_handler
#ifndef EVENT_SIGNAL_SENDER_HH_
#define EVENT_SIGNAL_SENDER_HH_
+#include <memory>
#include <string>
+#include <pkgmgr_installer.h>
+
#include "include/error_type.hh"
#include "include/request_type.hh"
class EventSignalSender {
public:
- EventSignalSender() : pkgid_(""), req_type_(ReqType::REQ_TYPE_UNKNOWN) {};
+ EventSignalSender(pkgmgr_installer* installer);
bool SendStart();
bool SendOK();
bool SendFail(ErrorType error);
void SetPkgID(std::string pkgid);
void SetReqType(ReqType req_type);
+ void SetUID(uid_t uid);
+ void SetSessionID(std::string session_id);
private:
+ bool SendSignal(const char* status, ErrorType error);
+
std::string pkgid_;
ReqType req_type_;
+ uid_t uid_;
+ std::string session_id_;
+ std::unique_ptr<pkgmgr_installer,
+ decltype(pkgmgr_installer_free)*> installer_;
};
} // res_handler
ParamChecker(int argc, char* argv[]);
ReqType GetRequestType();
std::string GetPkgID() const;
+ std::string GetSessionID() const;
uid_t GetUID() const;
const std::list<ResPathInfo>& GetPathList() const;
bool Validate();
class RequestHandlerInvoker {
public:
- RequestHandlerInvoker(ParamChecker option, EventSignalSender signal);
+ RequestHandlerInvoker(ParamChecker option,
+ std::shared_ptr<EventSignalSender> signal);
bool Validate();
bool Execute();
const std::string GetHandlerType() const;
private:
- std::unique_ptr<AbstractRequestHandler> handler_;
ParamChecker option_;
- EventSignalSender signal_;
+ std::unique_ptr<AbstractRequestHandler> handler_;
+ std::shared_ptr<EventSignalSender> signal_;
void SetReqHandler();
};
#include <iostream>
#include <string>
+#include <package-manager.h>
+#include <package-manager-types.h>
+
#include "include/error_type.hh"
#include "include/request_type.hh"
+#include "include/logging.hh"
namespace res_handler {
+EventSignalSender::EventSignalSender(pkgmgr_installer* installer)
+ : pkgid_(""), req_type_(ReqType::REQ_TYPE_UNKNOWN),
+ installer_(installer, pkgmgr_installer_free) {}
+
+bool EventSignalSender::SendSignal(const char* status, ErrorType error) {
+ if (!installer_)
+ return false;
+
+ std::unique_ptr<pkgmgr_res_event_info, decltype(pkgmgr_res_event_info_free)*>
+ event_info(pkgmgr_res_event_info_new(), pkgmgr_res_event_info_free);
+ if (!event_info) {
+ LOG(ERROR) << "Fail to create event info";
+ return false;
+ }
+
+ pkgmgr_res_event_info_set_error_code(event_info.get(),
+ static_cast<int>(error));
+
+ if (pkgmgr_installer_send_res_copy_signal(installer_.get(), pkgid_.c_str(),
+ status, event_info.get()) != 0) {
+ LOG(ERROR) << "Fail to send resource copy signal";
+ return false;
+ }
+
+ return true;
+}
+
bool EventSignalSender::SendStart() {
- std::cout << "EventSignalSender::SendStart" << std::endl;
+ if (!SendSignal(PKGMGR_INSTALLER_START_KEY_STR, ErrorType::ERROR_NONE)) {
+ LOG(ERROR) << "Fail to send start signal";
+ return false;
+ }
return true;
}
bool EventSignalSender::SendOK() {
- std::cout << "EventSignalSender::SendOK" << std::endl;
+ if (!SendSignal(PKGMGR_INSTALLER_OK_EVENT_STR, ErrorType::ERROR_NONE)) {
+ LOG(ERROR) << "Fail to send ok signal";
+ return false;
+ }
return true;
}
bool EventSignalSender::SendFail(ErrorType error) {
- std::cout << "EventSignalSender::SendFail" << std::endl;
+ if (!SendSignal(PKGMGR_INSTALLER_FAIL_EVENT_STR, error)) {
+ LOG(ERROR) << "Fail to send fail signal";
+ return false;
+ }
return true;
}
}
void EventSignalSender::SetReqType(ReqType req_type) {
+ if (req_type == ReqType::REQ_TYPE_NEW)
+ pkgmgr_installer_set_request_type(installer_.get(), PKGMGR_REQ_RES_COPY);
+ else if (req_type == ReqType::REQ_TYPE_CREATEDIR)
+ pkgmgr_installer_set_request_type(installer_.get(),
+ PKGMGR_REQ_RES_CREATE_DIR);
+ else if (req_type == ReqType::REQ_TYPE_REMOVE)
+ pkgmgr_installer_set_request_type(installer_.get(), PKGMGR_REQ_RES_REMOVE);
+ else if (req_type == ReqType::REQ_TYPE_UNINSTALL)
+ pkgmgr_installer_set_request_type(installer_.get(),
+ PKGMGR_REQ_RES_UNINSTALL);
req_type_ = req_type;
}
+void EventSignalSender::SetUID(uid_t uid) {
+ pkgmgr_installer_set_uid(installer_.get(), uid);
+ uid_ = uid;
+}
+
+void EventSignalSender::SetSessionID(std::string session_id) {
+ pkgmgr_installer_set_session_id(installer_.get(), session_id.c_str());
+ session_id_ = session_id;
+}
+
} // namespace res_handler
options.add_options()
("uid,u", bpo::value<int>()->default_value(0), "user id")
- ("session-id,k", bpo::value<std::string>(), "session id")
+ ("session-id,k", bpo::value<std::string>()->default_value(""),
+ "session id")
("path,p", bpo::value<std::vector<std::string>>()->multitoken(),
"source-destination path")
("remove,r", bpo::value<std::string>(), "remove shared resource")
return pkgid_;
}
+std::string ParamChecker::GetSessionID() const {
+ return session_id_;
+}
+
uid_t ParamChecker::GetUID() const {
return uid_;
}
namespace res_handler {
RequestHandlerInvoker::RequestHandlerInvoker(
- ParamChecker option, EventSignalSender signal) :
+ ParamChecker option, std::shared_ptr<EventSignalSender> signal) :
option_(option), signal_(signal) {
SetReqHandler();
}
bool RequestHandlerInvoker::Validate() {
if (handler_ == nullptr) {
LOG(ERROR) << "Failed to initialize handler";
+ signal_->SendFail(ErrorType::ERROR_SYSTEM_ERROR);
return false;
}
option_.GetRequestType(), option_.GetPathList())
!= ErrorType::ERROR_NONE) {
LOG(ERROR) << "Validation failed";
+ signal_->SendFail(ErrorType::ERROR_SYSTEM_ERROR);
return false;
}
}
bool RequestHandlerInvoker::Execute() {
- if (handler_ == nullptr)
+ if (handler_ == nullptr) {
+ signal_->SendFail(ErrorType::ERROR_SYSTEM_ERROR);
return false;
+ }
- if (handler_->Execute() != ErrorType::ERROR_NONE)
+ signal_->SendStart();
+ ErrorType ret = handler_->Execute();
+ if (ret != ErrorType::ERROR_NONE) {
+ signal_->SendFail(ret);
return false;
+ }
+ signal_->SendOK();
return true;
}
#include <iostream>
+#include <pkgmgr_installer.h>
+
#include "include/event_signal_sender.hh"
#include "include/logging.hh"
#include "include/param_checker.hh"
namespace res_handler {
bool ResHandler::Init(int argc, char* argv[]) {
+ pkgmgr_installer *installer = pkgmgr_installer_new();
+ if (!installer) {
+ LOG(ERROR) << "Fail to get pkgmgr installer";
+ return false;
+ }
+ std::shared_ptr<EventSignalSender> signal =
+ std::make_shared<EventSignalSender>(installer);
+
res_handler::ParamChecker option(argc, argv);
if (!option.Validate()) {
LOG(ERROR) << "Invalid argument has given";
+ signal->SendFail(ErrorType::ERROR_INVALID_PARAMETER);
return false;
}
+ signal->SetPkgID(option.GetPkgID());
+ signal->SetReqType(option.GetRequestType());
+ signal->SetUID(option.GetUID());
+ signal->SetSessionID(option.GetSessionID());
- res_handler::EventSignalSender signal;
- signal.SetPkgID(option.GetPkgID());
- signal.SetReqType(option.GetRequestType());
-
- handler_.reset(new res_handler::RequestHandlerInvoker(option, signal));
+ handler_.reset(new RequestHandlerInvoker(option, signal));
if (!handler_->Validate()) {
LOG(ERROR) << "Failed to initialize request handler";
return false;
PKG_CHECK_MODULES(pkgmgr-tool_unittests REQUIRED
dlog
gmock
+ pkgmgr
pkgmgr-parser
pkgmgr-info
+ pkgmgr-installer
libtzplatform-config
libsmack
sqlite3
class RequestHandlerInvokerTest : public TestFixture {
public:
RequestHandlerInvokerTest() : TestFixture(std::make_unique<Mocks>()) {
- signal_sender_.SetPkgID("org.tizen.targepkgid");
- signal_sender_.SetReqType(res_handler::ReqType::REQ_TYPE_UNKNOWN);
+ signal_sender_ = std::make_shared<res_handler::EventSignalSender>(nullptr);
+ signal_sender_->SetPkgID("org.tizen.targepkgid");
+ signal_sender_->SetReqType(res_handler::ReqType::REQ_TYPE_UNKNOWN);
}
virtual ~RequestHandlerInvokerTest() {}
virtual void SetUp() {}
virtual void TearDown() {}
- res_handler::EventSignalSender signal_sender_;
+ std::shared_ptr<res_handler::EventSignalSender> signal_sender_;
};
TEST_F(RequestHandlerInvokerTest, CopyType) {
projects / platform / core / appfw / pkgmgr-tool.git / commitdiff