Name: pkgmgr-info
Summary: Packager Manager infomation api for package
-Version: 0.22.10
+Version: 0.22.9
Release: 1
Group: Application Framework/Package Management
License: Apache-2.0
LOG(DEBUG) << "No packages meets given condition for user " << uid;
return PMINFO_R_ENOENT;
}
- for (auto& pkginfo : result_list) {
+ for (auto& pkginfo : result_list)
g_hash_table_insert(packages, reinterpret_cast<gpointer>(pkginfo->package),
reinterpret_cast<gpointer>(pkginfo.get()));
- }
return PMINFO_R_OK;
}
std::static_pointer_cast<pcp::AppInfoParcelable>(ptr));
std::vector<std::shared_ptr<application_x>> result_list = return_parcel->ExtractAppInfo();
- for (auto& app : result_list) {
+ for (auto& app : result_list)
g_hash_table_insert(packages, reinterpret_cast<gpointer>(app->appid),
reinterpret_cast<gpointer>(app.get()));
- }
return PMINFO_R_OK;
}
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+
+#ifndef CACHE_FLAG_HH_
+#define CACHE_FLAG_HH_
+
+#include <mutex>
+#include <shared_mutex>
+
+namespace pkgmgr_server {
+
+#ifndef EXPORT_API
+#define EXPORT_API __attribute__((visibility("default")))
+#endif
+
+class EXPORT_API CacheFlag {
+ public:
+ enum class EXPORT_API Status {
+ UNPREPARED,
+ PREPARING,
+ PREPARED
+ };
+
+ static bool SetPreparing() {
+ bool ret = false;
+ std::unique_lock<std::mutex> u(status_lock_);
+ if (status_ == Status::UNPREPARED) {
+ status_ = Status::PREPARING;
+ ret = true;
+ }
+ return ret;
+ }
+
+ static void SetStatus(Status status) {
+ std::unique_lock<std::mutex> u(status_lock_);
+ status_ = status;
+ }
+
+ static Status GetStatus() {
+ std::unique_lock<std::mutex> u(status_lock_);
+ return status_;
+ }
+
+ static std::unique_lock<std::shared_timed_mutex> GetWriterLock() {
+ return std::unique_lock<std::shared_timed_mutex>(lock_);
+ }
+
+ static void WriterUnLock() {
+ lock_.unlock();
+ }
+
+ static std::shared_lock<std::shared_timed_mutex> GetReaderLock() {
+ return std::shared_lock<std::shared_timed_mutex>(lock_, std::defer_lock);
+ }
+
+ static void ReaderUnLock() {
+ lock_.unlock_shared();
+ }
+
+ private:
+ static inline Status status_;
+ static inline std::mutex status_lock_;
+ static inline std::shared_timed_mutex lock_;
+};
+
+} // namespace pkgmgr_server
+
+#endif // CACHE_FLAG_HH_
#include <shared_mutex>
#include <vector>
-#include "cache_provider.hh"
+#include "cache_flag.hh"
#include "db_handle_provider.hh"
#include "utils/logging.hh"
return ret;
}
+int AppInfoDBHandler::GetHandleFromCache(
+ std::vector<std::pair<sqlite3*, uid_t>>& conn_list) {
+ bool is_write_op =
+ GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE;
+ int ret = PMINFO_R_OK;
+ std::string application;
+
+ for (auto* it = filter_->list; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
+ if (node->prop == E_PMINFO_APPINFO_PROP_APP_ID) {
+ application = node->value;
+ break;
+ }
+ }
+
+ std::vector<std::shared_ptr<application_x>> app_list;
+ for (auto& conn : conn_list) {
+ app_list = DBHandleProvider::GetInst(conn.second)
+ .GetApplications(
+ GetPID(), is_write_op, filter_, application);
+
+ handle_list_.reserve(app_list.size() + handle_list_.size());
+ std::move(std::begin(app_list), std::end(app_list),
+ std::back_inserter(handle_list_));
+ }
+
+ if (handle_list_.empty())
+ ret = PMINFO_R_ENOENT;
+
+ return ret;
+}
+
int AppInfoDBHandler::Execute() {
std::shared_lock<std::shared_timed_mutex> s(lock_);
SetOpType(pkgmgr_common::DBOperationType::OPERATION_TYPE_READ);
if (DBHandleProvider::GetInst(conn.second).IsWriter(GetPID()))
is_writer = true;
}
-
if (is_writer)
return GetHandleFromDB(conn_list);
- CacheProvider provider(GetUID());
- if (provider.IsPrepared() && provider.GetReadLock()) {
- bool is_write_op =
- GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE;
- int ret = PMINFO_R_OK;
- std::string application;
-
- for (auto* it = filter_->list; it != nullptr; it = g_slist_next(it)) {
- auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
- if (node->prop == E_PMINFO_APPINFO_PROP_APP_ID) {
- application = node->value;
- break;
- }
- }
-
- std::vector<std::shared_ptr<application_x>> app_list;
- for (auto& conn : conn_list) {
- app_list = CacheProvider(conn.second)
- .GetApplications(
- GetPID(), is_write_op, filter_, application);
- handle_list_.reserve(app_list.size() + handle_list_.size());
- std::move(std::begin(app_list), std::end(app_list),
- std::back_inserter(handle_list_));
- }
-
- if (handle_list_.empty())
- ret = PMINFO_R_ENOENT;
-
- return ret;
+ if (CacheFlag::GetStatus() == CacheFlag::Status::PREPARED) {
+ auto cache_lock = CacheFlag::GetReaderLock();
+ if (cache_lock.try_lock() &&
+ CacheFlag::GetStatus() == CacheFlag::Status::PREPARED)
+ return GetHandleFromCache(conn_list);
}
+
return GetHandleFromDB(conn_list);
}
protected:
int GetHandleFromDB(std::vector<std::pair<sqlite3*, uid_t>>& conn_list);
+ int GetHandleFromCache(std::vector<std::pair<sqlite3*, uid_t>>& conn_list);
pkgmgrinfo_filter_x* filter_;
std::vector<std::shared_ptr<application_x>> handle_list_;
uid_t uid_;
#include <shared_mutex>
#include <vector>
-#include "cache_provider.hh"
+#include "cache_flag.hh"
#include "db_handle_provider.hh"
#include "utils/logging.hh"
-namespace {
-
-uid_t globaluser_uid = -1;
-
-uid_t GetGlobalUID() {
- if (globaluser_uid == (uid_t)-1)
- globaluser_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
-
- return globaluser_uid;
-}
-
-uid_t ConvertUID(uid_t uid) {
- if (uid < REGULAR_USER)
- return GetGlobalUID();
- else
- return uid;
-}
-
-} // namespace
-
namespace pkgmgr_server {
namespace database {
std::vector<std::pair<sqlite3*, uid_t>> conn_list;
if (!Connect()) {
- CacheProvider(GetUID()).SetUnprepared();
+ CacheFlag::SetStatus(CacheFlag::Status::UNPREPARED);
return PMINFO_R_ERROR;
}
conn_list = GetConnection();
+ auto lock = CacheFlag::GetWriterLock();
int ret = PMINFO_R_OK;
-
for (auto& conn : conn_list) {
- if (conn.second != ConvertUID(uid_))
- continue;
-
- CacheProvider provider(conn.second);
- ret = provider.UpdateCache(conn.first, GetPID(), uid_, false, GetLocale());
+ ret = DBHandleProvider::GetInst(conn.second)
+ .UpdateCache(conn.first, GetPID(), uid_, false, GetLocale());
if (ret != PMINFO_R_OK) {
- LOG(ERROR) << "Failed to update pkginfo cache for uid["
- << uid_ << "], ret : " << ret;
+ LOG(ERROR) << "Failed to update pkginfo cache : " << ret;
break;
}
}
+ CacheFlag::SetStatus(ret == PMINFO_R_OK ?
+ CacheFlag::Status::PREPARED :
+ CacheFlag::Status::UNPREPARED);
+
return ret;
}
#include <string>
#include <vector>
-#include "cache_provider.hh"
+#include "cache_flag.hh"
#include "utils/logging.hh"
#include "pkgmgr-info.h"
db_path_list.emplace_back(
std::make_pair(global_parser_memdb_path, GetGlobalUID()));
} else {
- if (uid_ > REGULAR_USER) {
- db_path_list.emplace_back(
- std::make_pair(user_parser_filedb_path_, uid_));
- }
+ if (uid_ > REGULAR_USER)
+ db_path_list.emplace_back(std::make_pair(user_parser_filedb_path_, uid_));
db_path_list.emplace_back(
std::make_pair(global_parser_filedb_path_, GetGlobalUID()));
}
sqlite3* DBHandleProvider::CreateMemoryDBHandle(const std::string& filedb_path,
- const std::string& memorydb_path) {
+ const std::string& memorydb_path) {
sqlite3* memorydb = nullptr;
sqlite3* filedb = nullptr;
int ret = sqlite3_open_v2(memorydb_path.c_str(), &memorydb,
is_user_memdb_set_ = false;
is_global_memdb_set_ = false;
- CacheProvider provider(uid_);
- provider.ReleaseCache();
-
- if (ConvertUID(uid_) != GetGlobalUID())
- CacheProvider(GetGlobalUID()).ReleaseCache();
+ auto lock = CacheFlag::GetWriterLock();
+ CacheFlag::SetStatus(CacheFlag::Status::PREPARING);
+ pkg_map_.clear();
+ app_map_.clear();
+ CacheFlag::SetStatus(CacheFlag::Status::UNPREPARED);
LOG(DEBUG) << "Set Memory mode : File";
}
return true;
}
+void DBHandleProvider::TrimCache() {
+ std::unique_lock<std::recursive_mutex> u(lock_);
+ if (!released_)
+ ReleaseCache();
+}
+
+void DBHandleProvider::ReleaseCache() {
+ auto lock = CacheFlag::GetWriterLock();
+ CacheFlag::SetStatus(CacheFlag::Status::PREPARING);
+
+ app_map_.clear();
+ pkg_map_.clear();
+ CacheFlag::SetStatus(CacheFlag::Status::UNPREPARED);
+
+ released_ = true;
+}
+
bool DBHandleProvider::IsWriter(pid_t pid) {
std::unique_lock<std::mutex> u(pid_list_lock_);
return writer_pid_list_.find(pid) != writer_pid_list_.end();
}
+int DBHandleProvider::UpdateCache(sqlite3* db, pid_t pid, uid_t uid, bool write,
+ const std::string& locale) {
+ pkg_map_.clear();
+ app_map_.clear();
+
+ GHashTable* list = g_hash_table_new(g_str_hash, g_str_equal);
+ if (list == nullptr) {
+ LOG(ERROR) << "Out of memory";
+ return PMINFO_R_ERROR;
+ }
+
+ auto tmp_filter = reinterpret_cast<pkgmgrinfo_filter_x*>(
+ calloc(1, sizeof(pkgmgrinfo_filter_x)));
+ if (tmp_filter == nullptr) {
+ LOG(ERROR) << "Out of memory";
+ g_hash_table_destroy(list);
+ return PMINFO_R_ERROR;
+ }
+
+ int ret = pkginfo_internal_filter_get_list(db, tmp_filter, uid_,
+ locale.c_str(), list);
+ if (ret == PMINFO_R_OK) {
+ GHashTableIter iter;
+ gpointer value;
+ g_hash_table_iter_init(&iter, list);
+ while (g_hash_table_iter_next(&iter, nullptr, &value)) {
+ auto* pkg = reinterpret_cast<package_x*>(value);
+ std::string pkgid = pkg->package;
+ AddPackage(std::move(pkgid), pkg);
+ }
+ }
+
+ g_hash_table_destroy(list);
+ if (ret == PMINFO_R_ERROR) {
+ free(tmp_filter);
+ return ret;
+ }
+
+ std::vector<std::shared_ptr<application_x>> app_list;
+ ret = pkgmgr_server::internal::appinfo_internal_filter_get_list(db,
+ tmp_filter, uid_, uid, locale.c_str(), app_list);
+ free(tmp_filter);
+ if (ret == PMINFO_R_OK) {
+ for (auto& app : app_list) {
+ app->privileges = pkg_map_[app->package].front()->privileges;
+ std::string appid = app->appid;
+ AddApplication(std::move(appid), std::move(app));
+ }
+ }
+ released_ = false;
+
+ return ret;
+}
+
+std::vector<std::shared_ptr<package_x>> DBHandleProvider::GetPackages(
+ pid_t pid, bool write, pkgmgrinfo_filter_x* filter,
+ const std::string& package) {
+ std::vector<std::shared_ptr<package_x>> ret;
+ for (auto& info : pkg_map_[package]) {
+ bool pass = true;
+ for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
+ auto* checker = FilterCheckerProvider::GetInst().
+ GetPkgFilterChecker(node->prop);
+ if (!checker->CheckFilter(node, info.get())) {
+ pass = false;
+ break;
+ }
+ }
+ if (pass)
+ ret.push_back(info);
+ }
+
+ return ret;
+}
+
+void DBHandleProvider::AddPackage(std::string package, package_x* info) {
+ auto ptr = std::shared_ptr<package_x>(info, pkgmgrinfo_basic_free_package);
+ pkg_map_[package].push_back(ptr);
+ pkg_map_[""].push_back(std::move(ptr));
+}
+
+std::vector<std::shared_ptr<application_x>> DBHandleProvider::GetApplications(
+ pid_t pid, bool write, pkgmgrinfo_filter_x* filter,
+ const std::string& app) {
+ /* make metadata filter map */
+ std::unordered_map<std::string, std::string> metadata_map;
+ for (auto* it = filter->list_metadata; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_metadata_node_x*>(it->data);
+ if (node->key == nullptr)
+ continue;
+
+ metadata_map[node->key] = (node->value ? node->value : "");
+ }
+
+ std::vector<std::shared_ptr<application_x>> ret;
+ for (auto& info : app_map_[app]) {
+ bool pass = true;
+ for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
+ auto* checker = FilterCheckerProvider::GetInst().
+ GetAppFilterChecker(node->prop);
+ if (!checker->CheckFilter(node, info.get())) {
+ pass = false;
+ break;
+ }
+ }
+ if (!pass)
+ continue;
+
+ if (!metadata_map.empty()) {
+ pass = false;
+ for (auto* it = info->metadata; it != nullptr; it = g_list_next(it)) {
+ auto* node = reinterpret_cast<metadata_x*>(it->data);
+ if (node->key != nullptr) {
+ auto metadata = metadata_map.find(node->key);
+ if (metadata == metadata_map.end())
+ continue;
+
+ if (metadata->second.empty() ||
+ strcmp(node->value ? node->value : "",
+ metadata->second.c_str()) == 0) {
+ pass = true;
+ break;
+ }
+ }
+ }
+ }
+
+ if (pass)
+ ret.push_back(info);
+ }
+ return ret;
+}
+
+void DBHandleProvider::AddApplication(std::string app, std::shared_ptr<application_x> info) {
+ app_map_[app].push_back(info);
+ app_map_[""].push_back(std::move(info));
+}
+
void DBHandleProvider::InsertPID(pid_t pid) {
std::unique_lock<std::mutex> u(pid_list_lock_);
std::string GetCertDBPath(int pid, bool write);
void SetMemoryMode(pid_t pid);
void UnsetMemoryMode(pid_t pid);
+ int UpdateCache(sqlite3* db, pid_t pid, uid_t uid, bool write,
+ const std::string& locale);
+ std::vector<std::shared_ptr<package_x>> GetPackages(
+ pid_t pid, bool write, pkgmgrinfo_filter_x* filter,
+ const std::string& package);
+ std::vector<std::shared_ptr<application_x>> GetApplications(
+ pid_t pid, bool write, pkgmgrinfo_filter_x* filter,
+ const std::string& app);
+ void TrimCache();
bool IsWriter(pid_t pid);
private:
sqlite3* CreateMemoryDBHandle(const std::string& filedb_path,
const std::string& memorydb_path);
bool IsMemoryDBActive(pid_t pid, bool write);
+ void ReleaseCache();
+ void AddPackage(std::string package, package_x* info);
+ void AddApplication(std::string app, std::shared_ptr<application_x> info);
void InsertPID(pid_t pid);
bool ErasePID(pid_t pid);
parser_memdb_handle_;
std::string user_parser_memdb_path_;
std::string user_parser_filedb_path_;
+ bool released_ = true;
+ std::unordered_map<std::string, std::vector<std::shared_ptr<package_x>>>
+ pkg_map_;
+ std::unordered_map<std::string, std::vector<std::shared_ptr<application_x>>>
+ app_map_;
};
} // namespace database
#include <shared_mutex>
#include <vector>
-#include "cache_provider.hh"
+#include "cache_flag.hh"
#include "db_handle_provider.hh"
#include "pkgmgrinfo_debug.h"
return ret;
}
+int PkgGetDBHandler::GetHandleFromCache(
+ std::vector<std::pair<sqlite3*, uid_t>>& conn_list) {
+ int ret = PMINFO_R_OK;
+ std::string package;
+
+ for (auto* it = filter_->list; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
+ if (node->prop == E_PMINFO_PKGINFO_PROP_PACKAGE_ID) {
+ package = node->value;
+ break;
+ }
+ }
+
+ std::vector<std::shared_ptr<package_x>> pkg_list;
+ for (auto& conn : conn_list) {
+ pkg_list = DBHandleProvider::GetInst(conn.second)
+ .GetPackages(GetPID(), false, filter_, package);
+
+ handle_list_.reserve(pkg_list.size() + handle_list_.size());
+ std::move(std::begin(pkg_list), std::end(pkg_list),
+ std::back_inserter(handle_list_));
+ }
+
+ if (handle_list_.empty())
+ return PMINFO_R_ENOENT;
+
+ return ret;
+}
+
int PkgGetDBHandler::Execute() {
std::shared_lock<std::shared_timed_mutex> s(lock_);
SetOpType(pkgmgr_common::DBOperationType::OPERATION_TYPE_READ);
if (is_writer)
return GetHandleFromDB(conn_list);
- CacheProvider provider(GetUID());
- if (provider.IsPrepared() && provider.GetReadLock()) {
- int ret = PMINFO_R_OK;
- std::string package;
-
- for (auto* it = filter_->list; it != nullptr; it = g_slist_next(it)) {
- auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
- if (node->prop == E_PMINFO_PKGINFO_PROP_PACKAGE_ID) {
- package = node->value;
- break;
- }
- }
-
- std::vector<std::shared_ptr<package_x>> pkg_list;
- for (auto& conn : conn_list) {
- pkg_list = CacheProvider(conn.second)
- .GetPackages(GetPID(), false, filter_, package);
- handle_list_.reserve(pkg_list.size() + handle_list_.size());
- std::move(std::begin(pkg_list), std::end(pkg_list),
- std::back_inserter(handle_list_));
- }
-
- if (handle_list_.empty())
- return PMINFO_R_ENOENT;
-
- return ret;
+ if (CacheFlag::GetStatus() == CacheFlag::Status::PREPARED) {
+ auto cache_lock = CacheFlag::GetReaderLock();
+ if (cache_lock.try_lock() &&
+ CacheFlag::GetStatus() == CacheFlag::Status::PREPARED)
+ return GetHandleFromCache(conn_list);
}
return GetHandleFromDB(conn_list);
protected:
int GetHandleFromDB(std::vector<std::pair<sqlite3*, uid_t>>& conn_list);
+ int GetHandleFromCache(std::vector<std::pair<sqlite3*, uid_t>>& conn_list);
pkgmgrinfo_filter_x* filter_ = nullptr;
std::vector<std::shared_ptr<package_x>> handle_list_;
uid_t uid_;
#include "utils/logging.hh"
#include "db_handle_provider.hh"
-#include "cache_provider.hh"
#include "pkgmgrinfo_debug.h"
#include "pkgmgrinfo_internal.h"
}
}
__free_query_list(queries, args_list);
- CacheProvider(GetUID()).ReleaseCache();
-
+ database::DBHandleProvider::GetInst(GetUID()).TrimCache();
return ret;
}
return ret;
return pid_;
}
-void AbstractRequestHandler::SetUID(uid_t uid) {
- uid_ = uid;
-}
-
-uid_t AbstractRequestHandler::GetUID() {
- return uid_;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
virtual std::vector<uint8_t> ExtractResult() = 0;
void SetPID(pid_t pid);
- void SetUID(uid_t uid);
protected:
pid_t GetPID();
- uid_t GetUID();
private:
pid_t pid_;
- uid_t uid_;
};
} // namespace request_handler
bool CreateCacheRequestHandler::HandleRequest(unsigned char* data, int size,
const std::string& locale) {
- psd::CacheDBHandler db(GetUID(), GetPID());
+ // TODO(ilho159.kim) need to get logined user id
+ psd::CacheDBHandler db(5001, GetPID());
db.SetLocale(locale);
int ret = db.Execute();
#include <unordered_map>
#include <vector>
-#include "cache_provider.hh"
+#include "cache_flag.hh"
#include "create_cache_request.hh"
#include "cynara_checker.hh"
#include "pkg_request.hh"
#endif
#define LOG_TAG "PKGMGR_INFO"
-namespace {
-
-uid_t globaluser_uid = -1;
-
-uid_t GetGlobalUID() {
- if (globaluser_uid == (uid_t)-1)
- globaluser_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
-
- return globaluser_uid;
-}
-
-uid_t ConvertUID(uid_t uid) {
- if (uid < REGULAR_USER)
- return GetGlobalUID();
- else
- return uid;
-}
-
-} // namespace
-
namespace pkgmgr_server {
namespace {
}
auto req = std::make_shared<PkgRequest>(client_fd);
- if (!req->ReceiveData())
- return G_SOURCE_CONTINUE;
-
- pkgmgr_server::database::CacheProvider provider(req->GetSenderUID());
- if (provider.IsCachePreparationNecessary()) {
- runner->QueueRequest(
- std::make_shared<CreateCacheRequest>(req->GetSenderUID()));
- }
-
- if (ConvertUID(req->GetSenderUID()) != GetGlobalUID()) {
- pkgmgr_server::database::CacheProvider global_provider(GetGlobalUID());
- if (global_provider.IsCachePreparationNecessary()) {
+ if (req->ReceiveData()) {
+ pkgmgr_common::ReqType type = req->GetRequestType();
+ if (CacheFlag::SetPreparing()) {
runner->QueueRequest(
- std::make_shared<CreateCacheRequest>(GetGlobalUID()));
+ std::make_shared<CreateCacheRequest>(req->GetSenderUID()));
}
+ std::vector<std::string>&& privileges = GetPrivileges(type);
+ CynaraChecker::GetInst().CheckPrivilege(runner, req, privileges);
}
- pkgmgr_common::ReqType type = req->GetRequestType();
- std::vector<std::string>&& privileges = GetPrivileges(type);
- CynaraChecker::GetInst().CheckPrivilege(runner, req, privileges);
-
return G_SOURCE_CONTINUE;
}
#include <malloc.h>
#include "abstract_parcelable.hh"
-#include "cache_provider.hh"
#include "command_request_handler.hh"
#include "create_cache_request_handler.hh"
#include "create_db_request_handler.hh"
try {
handler[type]->SetPID(req->GetSenderPID());
- handler[type]->SetUID(req->GetSenderUID());
if (!handler[type]->HandleRequest(req->GetData(), req->GetSize(),
locale_.GetObject()))
LOG(ERROR) << "Failed to handle request";
database::DBHandleProvider::
GetInst(getuid()).UnsetMemoryMode(getpid());
- database::CacheProvider::ReleaseAll();
+ database::DBHandleProvider::
+ GetInst(getuid()).TrimCache();
+
return false;
}
projects / platform / core / appfw / pkgmgr-info.git / commitdiff