If there is an abnormally terminated installer process
apply the pending package info written by the process to the cache
Change-Id: Idc128d9dcddec3ba209996e2a09eea3ea687c0ce
Signed-off-by: ilho kim <ilho159.kim@samsung.com>
-bool DBHandleProvider::IsCrashedWriteRequest() {
+std::vector<pid_t> DBHandleProvider::CrashedWriteRequestPIDs() {
std::unique_lock<std::shared_mutex> u(pid_list_lock_);
if (writer_pid_list_.empty())
std::unique_lock<std::shared_mutex> u(pid_list_lock_);
if (writer_pid_list_.empty())
LOG(DEBUG) << "Check process count : " << writer_pid_list_.size();
std::vector<pid_t> remove_pids;
for (pid_t pid : writer_pid_list_) {
LOG(DEBUG) << "Check process count : " << writer_pid_list_.size();
std::vector<pid_t> remove_pids;
for (pid_t pid : writer_pid_list_) {
LOG(ERROR) << "Process is crashed : " << pid;
remove_pids.push_back(pid);
} else {
LOG(ERROR) << "Process is crashed : " << pid;
remove_pids.push_back(pid);
} else {
for (pid_t pid : remove_pids)
writer_pid_list_.erase(pid);
for (pid_t pid : remove_pids)
writer_pid_list_.erase(pid);
}
std::vector<std::pair<std::string, uid_t>> DBHandleProvider::GetParserDBPath() {
}
std::vector<std::pair<std::string, uid_t>> DBHandleProvider::GetParserDBPath() {
return writer_pid_list_.erase(pid) == 1;
}
return writer_pid_list_.erase(pid) == 1;
}
-void DBHandleProvider::RegisterPendingPackageInfo(package_x* info) {
+void DBHandleProvider::RegisterPendingPackageInfo(package_x* info, pid_t pid) {
if (!info || !info->package)
return;
if (!info || !info->package)
return;
- pending_pkg_.emplace(info->package);
+ InsertPID(pid);
+
+ pending_pkg_[pid].emplace(info->package);
}
void DBHandleProvider::UpdatePendingPackageInfo(const tizen_base::Database& db,
}
void DBHandleProvider::UpdatePendingPackageInfo(const tizen_base::Database& db,
- pid_t pid, uid_t uid, const std::string& locale) {
+ const std::vector<pid_t>& pids, uid_t uid, const std::string& locale) {
pkgmgrinfo_filter_x tmp_filter = { 0, };
pkgmgrinfo_node_x node = {
.prop = E_PMINFO_PKGINFO_PROP_PACKAGE_ID
pkgmgrinfo_filter_x tmp_filter = { 0, };
pkgmgrinfo_node_x node = {
.prop = E_PMINFO_PKGINFO_PROP_PACKAGE_ID
tmp_filter.cache_flag = true;
tmp_filter.list = g_slist_append(tmp_filter.list, (gpointer)&node);
std::map<std::string, std::shared_ptr<package_x>> pkgs;
tmp_filter.cache_flag = true;
tmp_filter.list = g_slist_append(tmp_filter.list, (gpointer)&node);
std::map<std::string, std::shared_ptr<package_x>> pkgs;
- for (const auto& pkg : pending_pkg_) {
- pkg_map_.erase(pkg);
- for (auto& appid : pkg_app_map_[pkg]) {
- app_map_.erase(appid);
+ for (const pid_t& pid : pids) {
+ for (const auto& pkg : pending_pkg_[pid]) {
+ pkg_map_.erase(pkg);
+ for (auto& appid : pkg_app_map_[pkg]) {
+ app_map_.erase(appid);
+ }
+
+ pkg_app_map_.erase(pkg);
+ node.value = const_cast<char*>(pkg.c_str());
+ internal::GetPkgInfo(db, &tmp_filter, uid_, locale, pkgs);
- pkg_app_map_.erase(pkg);
- node.value = const_cast<char*>(pkg.c_str());
- internal::GetPkgInfo(db, &tmp_filter, uid_, locale, pkgs);
+ pending_pkg_.erase(pid);
}
for (auto& [key, val] : pkgs)
}
for (auto& [key, val] : pkgs)
}
g_slist_free(tmp_filter.list);
}
g_slist_free(tmp_filter.list);
}
bool DBHandleProvider::UpdateCachePkg(const tizen_base::Database& db, uid_t uid,
}
bool DBHandleProvider::UpdateCachePkg(const tizen_base::Database& db, uid_t uid,
public:
~DBHandleProvider() = default;
static DBHandleProvider& GetInst(uid_t uid);
public:
~DBHandleProvider() = default;
static DBHandleProvider& GetInst(uid_t uid);
- static bool IsCrashedWriteRequest();
+ static std::vector<pid_t> CrashedWriteRequestPIDs();
static bool IsWriter(pid_t pid);
std::vector<std::pair<std::string, uid_t>> GetParserDBPath();
std::string GetCertDBPath();
static bool IsWriter(pid_t pid);
std::vector<std::pair<std::string, uid_t>> GetParserDBPath();
std::string GetCertDBPath();
pid_t pid, pkgmgrinfo_filter_x* filter,
const std::string& app);
void TrimCache();
pid_t pid, pkgmgrinfo_filter_x* filter,
const std::string& app);
void TrimCache();
- void RegisterPendingPackageInfo(package_x* info);
+ void RegisterPendingPackageInfo(package_x* info, pid_t pid);
void UpdatePendingPackageInfo(const tizen_base::Database& db,
void UpdatePendingPackageInfo(const tizen_base::Database& db,
- pid_t pid, uid_t uid, const std::string& locale);
+ const std::vector<pid_t>& pids, uid_t uid, const std::string& locale);
bool UpdateCachePkg(const tizen_base::Database& db, uid_t uid,
const std::string& pkgid, const std::string& locale);
bool UpdateCacheApp(const tizen_base::Database& db, uid_t uid,
bool UpdateCachePkg(const tizen_base::Database& db, uid_t uid,
const std::string& pkgid, const std::string& locale);
bool UpdateCacheApp(const tizen_base::Database& db, uid_t uid,
std::unordered_map<std::string, std::shared_ptr<package_x>> pkg_map_;
std::unordered_map<std::string, std::shared_ptr<application_x>> app_map_;
std::unordered_map<std::string, std::unordered_set<std::string>> pkg_app_map_;
std::unordered_map<std::string, std::shared_ptr<package_x>> pkg_map_;
std::unordered_map<std::string, std::shared_ptr<application_x>> app_map_;
std::unordered_map<std::string, std::unordered_set<std::string>> pkg_app_map_;
- std::unordered_set<std::string> pending_pkg_;
+ std::unordered_map<pid_t, std::unordered_set<std::string>> pending_pkg_;
};
} // namespace database
};
} // namespace database
auto lock = CacheFlag::GetWriterLock();
if (CacheFlag::GetStatus() == CacheFlag::Status::PREPARED)
auto lock = CacheFlag::GetWriterLock();
if (CacheFlag::GetStatus() == CacheFlag::Status::PREPARED)
- DBHandleProvider::GetInst(uid_).RegisterPendingPackageInfo(package_);
+ DBHandleProvider::GetInst(uid_)
+ .RegisterPendingPackageInfo(package_, GetPID());
namespace pkgmgr_server {
namespace database {
namespace pkgmgr_server {
namespace database {
-RemoveCacheDBHandler::RemoveCacheDBHandler(uid_t uid, int pid)
- : AbstractDBHandler(uid, pid), uid_(uid) {}
+RemoveCacheDBHandler::RemoveCacheDBHandler(uid_t uid, std::vector<pid_t> pids)
+ : AbstractDBHandler(uid, 0), uid_(uid), pids_(std::move(pids)) {}
int RemoveCacheDBHandler::Execute() {
std::unique_lock<std::shared_mutex> u(lock_);
int RemoveCacheDBHandler::Execute() {
std::unique_lock<std::shared_mutex> u(lock_);
CacheFlag::SetStatus(CacheFlag::Status::PREPARING);
for (const auto& [db, uid] : conn_list) {
auto& provider = database::DBHandleProvider::GetInst(uid);
CacheFlag::SetStatus(CacheFlag::Status::PREPARING);
for (const auto& [db, uid] : conn_list) {
auto& provider = database::DBHandleProvider::GetInst(uid);
- provider.UpdatePendingPackageInfo(db, GetPID(), uid_, GetLocale());
+ provider.UpdatePendingPackageInfo(db, pids_, uid_, GetLocale());
}
CacheFlag::SetStatus(CacheFlag::Status::PREPARED);
}
CacheFlag::SetStatus(CacheFlag::Status::PREPARED);
#include "abstract_db_handler.hh"
namespace pkgmgr_server {
#include "abstract_db_handler.hh"
namespace pkgmgr_server {
class EXPORT_API RemoveCacheDBHandler : public AbstractDBHandler {
public:
class EXPORT_API RemoveCacheDBHandler : public AbstractDBHandler {
public:
- RemoveCacheDBHandler(uid_t uid, int pid);
+ RemoveCacheDBHandler(uid_t uid, std::vector<pid_t> pids);
int Execute() override;
private:
uid_t uid_;
int Execute() override;
private:
uid_t uid_;
+ std::vector<pid_t> pids_;
};
} // namespace database
};
} // namespace database
}
if (parcel->GetCmd() == CommandType::RemoveCache) {
}
if (parcel->GetCmd() == CommandType::RemoveCache) {
- database::RemoveCacheDBHandler db(parcel->GetUid(), GetPID());
+ database::RemoveCacheDBHandler db(parcel->GetUid(), {GetPID()});
db.SetLocale(locale);
int ret = db.Execute();
result_ = std::make_shared<pcp::ResultParcelable>(
db.SetLocale(locale);
int ret = db.Execute();
result_ = std::make_shared<pcp::ResultParcelable>(
#include "cynara_checker.hh"
#include "request_handler_factory.hh"
#include "server/database/db_handle_provider.hh"
#include "cynara_checker.hh"
#include "request_handler_factory.hh"
#include "server/database/db_handle_provider.hh"
+#include "server/database/remove_cache_db_handler.hh"
#include "utils/logging.hh"
#include "pkgmgrinfo_debug.h"
#include "utils/logging.hh"
#include "pkgmgrinfo_debug.h"
+ auto crashed_writer_pids =
+ database::DBHandleProvider::CrashedWriteRequestPIDs();
+ if (!crashed_writer_pids.empty()) {
+ database::RemoveCacheDBHandler db(getuid(), std::move(crashed_writer_pids));
+ db.SetLocale(h->locale_.GetObject());
+ db.Execute();
+ }
+
sqlite3_release_memory(-1);
malloc_trim(0);
return G_SOURCE_REMOVE;
sqlite3_release_memory(-1);
malloc_trim(0);
return G_SOURCE_REMOVE;