From: Junghyun Yeon Date: Wed, 18 Aug 2021 10:21:51 +0000 (+0900) Subject: Change prefix rsc to res X-Git-Tag: submit/tizen/20210826.063234~8 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=858b6dc100f7352ee0a916100a8a552a0d2c5e7f;p=platform%2Fcore%2Fappfw%2Fpkgmgr-tool.git Change prefix rsc to res "res" is more common word for representing "resource" than "rsc". Change-Id: I32c71d86a056a1c5127282e9fe0d69db8bc6e627 Signed-off-by: Junghyun Yeon --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 65798988..adb4e43 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,7 +16,7 @@ SET(TARGET_PKG_GETSIZE "pkg_getsize") SET(TARGET_PKG_CLEARDATA "pkg_cleardata") SET(TARGET_INSTALL_PRELOAD_PKG "install_preload_pkg") SET(TARGET_PKG_UPGRADE "pkg_upgrade") -SET(TARGET_RSC_COPY "rsc-copy") +SET(TARGET_RES_COPY "res-copy") SET(TARGET_RSC_SLICE "rsc-slice") SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") diff --git a/packaging/pkgmgr-tool.spec b/packaging/pkgmgr-tool.spec index a15b27b..2562d5a 100644 --- a/packaging/pkgmgr-tool.spec +++ b/packaging/pkgmgr-tool.spec @@ -111,7 +111,7 @@ update-mime-database %{_datadir}/mime %{_bindir}/pkg_cleardata %{_bindir}/pkginfo %{_bindir}/rsc-slice -%{_bindir}/rsc-copy +%{_bindir}/res-copy %{_bindir}/pkg_upgrade %attr(0755,root,root) %{_bindir}/install_preload_pkg %{_datadir}/mime/packages/mime.wac.xml diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3812999..26e73c4 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -4,5 +4,5 @@ ADD_SUBDIRECTORY(pkg_getsize) ADD_SUBDIRECTORY(pkg_upgrade) ADD_SUBDIRECTORY(pkgcmd) ADD_SUBDIRECTORY(pkginfo) -ADD_SUBDIRECTORY(rsc-copy) +ADD_SUBDIRECTORY(res-copy) ADD_SUBDIRECTORY(rsc-slice) diff --git a/src/res-copy/CMakeLists.txt b/src/res-copy/CMakeLists.txt new file mode 100644 index 0000000..1e960e1 --- /dev/null +++ b/src/res-copy/CMakeLists.txt @@ -0,0 +1,19 @@ +# Target - sources +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRCS) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include) + +# Target - definition +ADD_EXECUTABLE(${TARGET_RES_COPY} ${SRCS}) + +# Dependency +APPLY_PKG_CONFIG(${TARGET_RES_COPY} PUBLIC + AUL_DEPS + GLIB_DEPS + BUNDLE_DEPS + Boost + PKGMGR_INFO_DEPS + TZPLATFORM_DEPS +) + +# Install +INSTALL(TARGETS ${TARGET_RES_COPY} DESTINATION bin) \ No newline at end of file diff --git a/src/res-copy/include/abstract_request_handler.hh b/src/res-copy/include/abstract_request_handler.hh new file mode 100644 index 0000000..09c79ce --- /dev/null +++ b/src/res-copy/include/abstract_request_handler.hh @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 ABSTRACT_REQUEST_HANDLER_HH_ +#define ABSTRACT_REQUEST_HANDLER_HH_ + +#include +#include + +#include "include/error_type.hh" +#include "include/res_path_info.hh" + +namespace res_handler { + +class AbstractRequestHandler { + public: + AbstractRequestHandler( + std::string pkgid, std::string root_path, std::list path_list) : + pkgid_(pkgid), root_path_(root_path), path_list_(path_list) {}; + + virtual ErrorType Execute() = 0; + virtual const std::string GetRequestHandlerType() const = 0; + + protected: + std::string GetRootPath(); + const std::string GetPkgID() const; + const std::list GetPathList() const; + + private: + std::string pkgid_; + std::string root_path_; + std::list path_list_; +}; + +} // namespace res_handler + +#endif // ABSTRACT_REQUEST_HANDLER_HH_ diff --git a/src/res-copy/include/condition_validator.hh b/src/res-copy/include/condition_validator.hh new file mode 100644 index 0000000..ca10a5a --- /dev/null +++ b/src/res-copy/include/condition_validator.hh @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 CONDITION_VALIDATOR_HH_ +#define CONDITION_VALIDATOR_HH_ + +#include +#include + +#include "include/error_type.hh" +#include "include/res_path_info.hh" +#include "include/request_type.hh" + +namespace res_handler { + +class ConditionValidator { + public: + ConditionValidator(std::string pkgid, uid_t uid); + ErrorType ValidateCondition(ReqType req_type, + std::list path_list); + + private: + std::string pkgid_; + std::string root_path_; + uid_t uid_; + + ErrorType CheckCopyRequest(std::list path_list); + ErrorType CheckRemoveRequest(std::list path_list); +}; + +} // namespace res_handler + +#endif // CONDITION_VALIDATOR_HH_ diff --git a/src/res-copy/include/copy_request_handler.hh b/src/res-copy/include/copy_request_handler.hh new file mode 100644 index 0000000..66bb747 --- /dev/null +++ b/src/res-copy/include/copy_request_handler.hh @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 COPY_REQUEST_HANDLER_HH_ +#define COPY_REQUEST_HANDLER_HH_ + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/error_type.hh" +#include "include/res_path_info.hh" + +namespace res_handler { + +class CopyRequestHandler : public AbstractRequestHandler { + public: + CopyRequestHandler(std::string pkgid, std::string root_path, + std::list path_list); + + ErrorType Execute() override; + const std::string GetRequestHandlerType() const override; +}; + +} // namespace res_handler + +#endif // COPY_REQUEST_HANDLER_HH_ diff --git a/src/res-copy/include/error_type.hh b/src/res-copy/include/error_type.hh new file mode 100644 index 0000000..3d25689 --- /dev/null +++ b/src/res-copy/include/error_type.hh @@ -0,0 +1,35 @@ +/* + * 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 ERROR_TYPE_HH_ +#define ERROR_TYPE_HH_ + +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 +}; + +} // namespace res_handler + +#endif // ERROR_TYPE_HH_ diff --git a/src/res-copy/include/event_signal_sender.hh b/src/res-copy/include/event_signal_sender.hh new file mode 100644 index 0000000..9bb5fb3 --- /dev/null +++ b/src/res-copy/include/event_signal_sender.hh @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 EVENT_SIGNAL_SENDER_HH_ +#define EVENT_SIGNAL_SENDER_HH_ + +#include + +#include "include/error_type.hh" +#include "include/request_type.hh" + +namespace res_handler { + +class EventSignalSender { + public: + EventSignalSender() : pkgid_(""), req_type_(ReqType::REQ_TYPE_UNKNOWN) {}; + bool SendStart(); + bool SendOK(); + bool SendFail(ErrorType error); + void SetPkgID(std::string pkgid); + void SetReqType(ReqType req_type); + + private: + std::string pkgid_; + ReqType req_type_; +}; + +} // res_handler + +#endif // PARAM_CHECKER_HH_ diff --git a/src/res-copy/include/file_util.hh b/src/res-copy/include/file_util.hh new file mode 100644 index 0000000..bcb786e --- /dev/null +++ b/src/res-copy/include/file_util.hh @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 FILE_UTIL_HH_ +#define FILE_UTIL_HH_ + +#include +#include + +namespace res_handler { + +// TODO(jungh.yeon) : is this necessary? +enum FSFlag : int { + FS_NONE = 0, + FS_MERGE_SKIP = (1 << 0), + FS_MERGE_OVERWRITE = (1 << 1), + FS_COMMIT_COPY_FILE = (1 << 2), + FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS = (1 << 3) +}; + +FSFlag operator|(FSFlag a, FSFlag b); + +bool CreateDir(const boost::filesystem::path& path); + +bool CopyDir(const boost::filesystem::path& src, + const boost::filesystem::path& dst, + FSFlag flags = FS_NONE, bool skip_symlink = false); + +bool CopyFile(const boost::filesystem::path& src, + const boost::filesystem::path& dst); + +bool RemoveAll(const boost::filesystem::path& path); + +} // namespace res_handler + +#endif // FILE_UTIL_HH_ diff --git a/src/res-copy/include/logging.hh b/src/res-copy/include/logging.hh new file mode 100644 index 0000000..814e875 --- /dev/null +++ b/src/res-copy/include/logging.hh @@ -0,0 +1,180 @@ +// Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved +// Use of this source code is governed by a apache 2.0 license that can be +// found in the LICENSE file. + +#ifndef LOGGING_HH_ +#define LOGGING_HH_ + +#include + +#ifndef PROJECT_TAG +#define PROJECT_TAG "PKGMGR_TOOL" +#endif + +#ifdef LOG +#undef LOG +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __FILENAME__ +#define __FILENAME__ \ + (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) +#endif + +namespace utils { + +enum class LogLevel { + LOG_ERROR, + LOG_WARNING, + LOG_INFO, + LOG_DEBUG, +}; + +log_priority LogLevelToPriority(LogLevel level); + +template struct LogTag; +template<> struct LogTag { + static constexpr const char* value = "\033[1;31m| ERROR |\033[0m"; +}; +template<> struct LogTag { + static constexpr const char* value = "\033[1;33m| WARNING |\033[0m"; +}; +template<> struct LogTag { + static constexpr const char* value = "\033[1;32m| INFO |\033[0m"; +}; +template<> struct LogTag { + static constexpr const char* value = "\033[0m| DEBUG |\033[0m"; +}; + +template > +class StringStream : private std::basic_ostringstream { + public: + using std::basic_ostringstream::str; + + template + StringStream& operator<<(const T& value) { + static_cast &>(*this) << value; + return *this; + } +}; + +// Interface class for logging backends. The custom LogBackend which wants +// log using LOG() macro should be implement following interface. +class ILogBackend { + public: + virtual void WriteLog(LogLevel level, const std::string& tag, + const std::string& logstr) = 0; +}; + +class DLogBackend : public ILogBackend { + public: + void WriteLog(LogLevel level, const std::string& tag, + const std::string& logstr) override { + dlog_print(LogLevelToPriority(level), tag.c_str(), "%s", + Escape(logstr).c_str()); + } + + private: + // Since LogCatcher passes input to dlog_print(), the input which contains + // format string(such as %d, %n) can cause unexpected result. + // This is simple function to escape '%'. + // NOTE: Is there any gorgeous way instead of this? + std::string Escape(const std::string& str) const { + std::string escaped = std::string(str); + size_t start_pos = 0; + std::string from = "%"; + std::string to = "%%"; + while ((start_pos = escaped.find(from, start_pos)) != std::string::npos) { + escaped.replace(start_pos, from.length(), to); + start_pos += to.length(); + } + return escaped; + } +}; + +class LogCore { + public: + // Do not call this function at destructor of global object + static LogCore& GetCore() { + static LogCore core; + return core; + } + + void AddLogBackend(std::shared_ptr backend) { + backend_list_.emplace_back(backend); + } + + void Log(LogLevel level, const std::string& tag, const std::string& log) { + for (auto& backend : backend_list_) + backend->WriteLog(level, tag, log); + } + + private: + LogCore() { + // add default dlog backend + AddLogBackend(std::shared_ptr(new DLogBackend())); + } + ~LogCore() = default; + LogCore(const LogCore&) = delete; + LogCore& operator=(const LogCore&) = delete; + + std::vector> backend_list_; +}; + +class LogCatcher { + public: + LogCatcher(LogLevel level, const char* tag) + : level_(level), tag_(tag) { } + + void operator&(const StringStream& str) const { + LogCore::GetCore().Log(level_, tag_, str.str()); + } + + private: + LogLevel level_; + std::string tag_; +}; + +} // namespace utils + + +inline static const constexpr char* __tag_for_logging() { + return ""; +} + +inline static const constexpr char* __tag_for_project() { + return PROJECT_TAG; +} + +// To be defined in class namespace if user want different log tag for given +// scope +#define SCOPE_LOG_TAG(TAG) \ + inline static const constexpr char* __tag_for_logging() { \ + return #TAG; \ + } \ + +// Simple logging macro of following usage: +// LOG(LEVEL) << object_1 << object_2 << object_n; +// where: +// LEVEL = ERROR | WARNING | INFO | DEBUG +#define LOG(LEVEL) \ + ::utils::LogCatcher( \ + ::utils::LogLevel::LOG_ ## LEVEL, __tag_for_project()) \ + & ::utils::StringStream() \ + << std::string(::utils::LogTag<::utils::LogLevel::LOG_ ## LEVEL>::value) \ + << " " << std::setw(25) << std::left << __tag_for_logging() \ + << " : " << std::setw(36) \ + << (std::string(__FILENAME__) + ":" + std::to_string(__LINE__)).c_str() \ + << std::setw(0) << " : " \ + +#endif // LOGGING_HH_ diff --git a/src/res-copy/include/param_checker.hh b/src/res-copy/include/param_checker.hh new file mode 100644 index 0000000..437a0e2 --- /dev/null +++ b/src/res-copy/include/param_checker.hh @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 PARAM_CHECKER_HH_ +#define PARAM_CHECKER_HH_ + +#include +#include + +#include "include/request_type.hh" +#include "include/res_path_info.hh" + +namespace res_handler { + +class ParamChecker { + public: + ParamChecker(int argc, char* argv[]); + ReqType GetRequestType(); + std::string GetPkgID() const; + uid_t GetUID() const; + const std::list& GetPathList() const; + bool Validate(); + + private: + std::list path_info_list_; + std::string pkgid_; + std::string session_id_; + uid_t uid_ = 0; + ReqType req_type_ = ReqType::REQ_TYPE_UNKNOWN; + + void SetRequestType(std::string key); + bool ValidatePkgID(); +}; + +} // res_handler + +#endif // PARAM_CHECKER_HH_ diff --git a/src/res-copy/include/remove_request_handler.hh b/src/res-copy/include/remove_request_handler.hh new file mode 100644 index 0000000..a378a79 --- /dev/null +++ b/src/res-copy/include/remove_request_handler.hh @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 REMOVE_REQUEST_HANDLER_HH_ +#define REMOVE_REQUEST_HANDLER_HH_ + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/error_type.hh" +#include "include/res_path_info.hh" + +namespace res_handler { + +class RemoveRequestHandler : public AbstractRequestHandler { + public: + RemoveRequestHandler( + std::string pkgid, std::string root_path, + std::list path_list); + + ErrorType Execute() override; + const std::string GetRequestHandlerType() const override; +}; + +} // namespace res_handler + +#endif // REMOVE_REQUEST_HANDLER_HH_ diff --git a/src/res-copy/include/request_handler_invoker.hh b/src/res-copy/include/request_handler_invoker.hh new file mode 100644 index 0000000..d4fff8b --- /dev/null +++ b/src/res-copy/include/request_handler_invoker.hh @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 REQUEST_HANDLER_INVOKER_HH_ +#define REQUEST_HANDLER_INVOKER_HH_ + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/event_signal_sender.hh" +#include "include/param_checker.hh" + +namespace res_handler { + +class RequestHandlerInvoker { + public: + RequestHandlerInvoker(ParamChecker option, EventSignalSender signal); + + bool Validate(); + bool Execute(); + const std::string GetHandlerType() const; + + private: + std::unique_ptr handler_; + ParamChecker option_; + EventSignalSender signal_; + + void SetReqHandler(); +}; + +} // namespace res_handler + +#endif // REQUEST_HANDLER_INVOKER_HH_ diff --git a/src/res-copy/include/request_type.hh b/src/res-copy/include/request_type.hh new file mode 100644 index 0000000..7cf97b7 --- /dev/null +++ b/src/res-copy/include/request_type.hh @@ -0,0 +1,31 @@ +/* + * 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 REQUEST_TYPE_HH_ +#define REQUEST_TYPE_HH_ + +namespace res_handler { + +enum ReqType { + REQ_TYPE_NEW = 0, + REQ_TYPE_REMOVE = 1, + REQ_TYPE_UNINSTALL, + REQ_TYPE_UNKNOWN +}; + +} // namespace res_handler + +#endif // REQUEST_TYPE_HH_ diff --git a/src/res-copy/include/res_handler.hh b/src/res-copy/include/res_handler.hh new file mode 100644 index 0000000..c0bff45 --- /dev/null +++ b/src/res-copy/include/res_handler.hh @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 RES_HANDLER_HH_ +#define RES_HANDLER_HH_ + +#include + +#include "include/request_handler_invoker.hh" + +namespace res_handler { + +class ResHandler { + public: + ResHandler() {}; + bool Init(int argc, char* argv[]); + bool Run(); + + private: + std::unique_ptr handler_; +}; + +} // namespace res_handler + +#endif // RES_HANDLER_HH_ diff --git a/src/res-copy/include/res_path_info.hh b/src/res-copy/include/res_path_info.hh new file mode 100644 index 0000000..d85fb57 --- /dev/null +++ b/src/res-copy/include/res_path_info.hh @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 RES_PATH_INFO_HH_ +#define RES_PATH_INFO_HH_ + +#include + +namespace res_handler { + +class ResPathInfo { + public: + ResPathInfo(std::string src, std::string dst); + + const std::string& GetSrcPath() const; + const std::string& GetDstPath() const; + + private: + std::string src_; + std::string dst_; +}; + +} // namespace res_handler + +#endif // RES_PATH_INFO_HH_ diff --git a/src/res-copy/include/uninstall_request_handler.hh b/src/res-copy/include/uninstall_request_handler.hh new file mode 100644 index 0000000..55997bf --- /dev/null +++ b/src/res-copy/include/uninstall_request_handler.hh @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 UNINSTALL_REQUEST_HANDLER_HH_ +#define UNINSTALL_REQUEST_HANDLER_HH_ + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/error_type.hh" +#include "include/res_path_info.hh" + +namespace res_handler { + +class UninstallRequestHandler : public AbstractRequestHandler { + public: + UninstallRequestHandler( + std::string pkgid, std::string root_path, std::list path_list); + + ErrorType Execute() override; + const std::string GetRequestHandlerType() const override; +}; + +} // namespace res_handler + +#endif // UNINSTALL_REQUEST_HANDLER_HH_ diff --git a/src/res-copy/src/abstract_request_handler.cc b/src/res-copy/src/abstract_request_handler.cc new file mode 100644 index 0000000..24f34f7 --- /dev/null +++ b/src/res-copy/src/abstract_request_handler.cc @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/abstract_request_handler.hh" + +#include + +#include "include/request_type.hh" +#include "include/res_path_info.hh" + +namespace res_handler { + +std::string AbstractRequestHandler::GetRootPath() { + return root_path_; +} + +const std::string AbstractRequestHandler::GetPkgID() const { + return pkgid_; +} + +const std::list AbstractRequestHandler::GetPathList() const { + return path_list_; +} + +} // namespace res_handler diff --git a/src/res-copy/src/condition_validator.cc b/src/res-copy/src/condition_validator.cc new file mode 100644 index 0000000..095cb6e --- /dev/null +++ b/src/res-copy/src/condition_validator.cc @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/condition_validator.hh" + +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "include/logging.hh" +#include "include/request_type.hh" +#include "include/res_path_info.hh" + +#include + +namespace bf = boost::filesystem; + +namespace { + +std::string GetRootPath(uid_t uid) { + tzplatform_set_user(uid); + const char* rootpath = tzplatform_getenv(TZ_USER_HOME); + tzplatform_reset_user(); + return rootpath; +} + +bool IsPackageExists(std::string pkgid, uid_t uid) { + pkgmgrinfo_pkginfo_h handle; + if (pkgmgrinfo_pkginfo_get_usr_pkginfo( + pkgid.c_str(), uid, &handle) != PMINFO_R_OK) { + LOG(ERROR) << "package not exists : " << pkgid; + return false; + } + pkgmgrinfo_pkginfo_destroy_pkginfo(handle); + + return true; +} + +bool CheckFreeSpaceAtPath(int64_t required_size, + const bf::path& target_location) { + boost::system::error_code error; + bf::path root = target_location; + + while (!bf::exists(root) && root != root.root_path()) + root = root.parent_path(); + + if (!bf::exists(root)) { + LOG(ERROR) << "No mount point for path: " << target_location; + return false; + } + + bf::space_info space_info = bf::space(root, error); + if (error) { + LOG(ERROR) << "Failed to get space_info: " << error.message(); + return false; + } + + return (space_info.free >= static_cast(required_size)); +} + +int64_t GetBlockSizeForPath(const bf::path& path_in_partition) { + struct stat stats; + if (stat(path_in_partition.string().c_str(), &stats)) { + LOG(ERROR) << "stat(" << path_in_partition.string() + << ") failed - error code: " << errno; + return -1; + } + return stats.st_blksize; +} + +int64_t RoundUpToBlockSizeOf(int64_t size, int64_t block_size) { + return ((size + block_size - 1) / block_size) * block_size; +} + +int64_t GetDirectorySize(const bf::path& path) { + int64_t block_size = GetBlockSizeForPath(path); + + if (block_size == -1) + return -1; + + int64_t size = 0; + for (bf::recursive_directory_iterator iter(path); + iter != bf::recursive_directory_iterator(); ++iter) { + struct stat buf; + if (lstat(iter->path().c_str(), &buf) == -1) { + LOG(ERROR) << "lstat() failed for: " << iter->path(); + return -1; + } + size += RoundUpToBlockSizeOf(buf.st_size, block_size); + } + + return size; +} + +} // namespace + +namespace res_handler { + +ConditionValidator::ConditionValidator(std::string pkgid, uid_t uid) : + pkgid_(pkgid), uid_(uid) { + root_path_ = GetRootPath(uid_); +} + +ErrorType ConditionValidator::ValidateCondition(ReqType req_type, + std::list path_list) { + if (!IsPackageExists(pkgid_, uid_)) + return ErrorType::ERROR_PKG_NOT_FOUND; + + if (req_type == ReqType::REQ_TYPE_NEW) + return CheckCopyRequest(path_list); + else if (req_type == ReqType::REQ_TYPE_REMOVE) + return CheckRemoveRequest(path_list); + + return ErrorType::ERROR_NONE; +} + +ErrorType ConditionValidator::CheckCopyRequest( + std::list path_list) { + boost::filesystem::path src_root_path(root_path_); + uintmax_t res_size = 0; + + src_root_path = src_root_path / "apps_rw" / pkgid_; + for (auto& path_info : path_list) { + boost::filesystem::path res_path(src_root_path); + res_path = res_path / path_info.GetSrcPath(); + if (!boost::filesystem::exists(res_path)) { + LOG(ERROR) << "Resource not exists : " << res_path; + return ErrorType::ERROR_RES_NOT_FOUND; + } + + if (boost::filesystem::is_directory(res_path)) + res_size += GetDirectorySize(res_path); + else + res_size += boost::filesystem::file_size(res_path); + + } + LOG(INFO) << "Required size for resource: " << res_size; + + if (!CheckFreeSpaceAtPath(static_cast(res_size), root_path_)) { + LOG(ERROR) << "Not enough space for resource"; + return ErrorType::ERROR_OUT_OF_SPACE; + } + + return ErrorType::ERROR_NONE; +} + +ErrorType ConditionValidator::CheckRemoveRequest( + std::list path_list) { + for (auto& path_info : path_list) { + boost::filesystem::path dst_path(root_path_); + dst_path = dst_path / "shared_res"/ pkgid_ / path_info.GetDstPath(); + if (!boost::filesystem::exists(dst_path)) { + LOG(ERROR) << "Resource not exists : " << dst_path; + return ErrorType::ERROR_RES_NOT_FOUND; + } + } + + return ErrorType::ERROR_NONE; +} + +} // namespace res_handler diff --git a/src/res-copy/src/copy_request_handler.cc b/src/res-copy/src/copy_request_handler.cc new file mode 100644 index 0000000..ff76159 --- /dev/null +++ b/src/res-copy/src/copy_request_handler.cc @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/copy_request_handler.hh" + +#include +#include + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/error_type.hh" +#include "include/file_util.hh" +#include "include/logging.hh" +#include "include/res_path_info.hh" + +namespace bf = boost::filesystem; + +namespace { + +constexpr char kCopyReqHandlerType[] = "copy"; + +} // namespace + +namespace res_handler { + +CopyRequestHandler::CopyRequestHandler( + std::string pkgid, std::string root_path, + std::list path_list) : + AbstractRequestHandler(pkgid, root_path, path_list) {} + +ErrorType CopyRequestHandler::Execute() { + bf::path root_path(GetRootPath()); + bf::path src_root_path = root_path / "apps_rw" / GetPkgID(); + bf::path dst_root_path = root_path / "shared_res" / GetPkgID(); + + if (!CreateDir(dst_root_path)) + return ErrorType::ERROR_SYSTEM_ERROR; + + for (auto& path_info : GetPathList()) { + bf::path src_path = src_root_path / path_info.GetSrcPath(); + if (!bf::exists(src_path)) { + LOG(ERROR) << "Path not exists :" << src_path; + return ErrorType::ERROR_RES_NOT_FOUND; + } + + bf::path dst_path = dst_root_path / path_info.GetDstPath(); + + if (bf::is_directory(src_path)) { + if (!CopyDir(src_path, dst_path, + FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS, true)) { + LOG(ERROR) << "Failed to copy directory " << src_path; + return ErrorType::ERROR_SYSTEM_ERROR; + } + } else { + if (bf::is_directory(dst_path)) + dst_path /= src_path.filename(); + + if (!CopyFile(src_path, dst_path)) { + LOG(ERROR) << "Failed to copy directory " << src_path; + return ErrorType::ERROR_SYSTEM_ERROR; + } + } + } + + return ErrorType::ERROR_NONE; +} + +const std::string CopyRequestHandler::GetRequestHandlerType() const { + return kCopyReqHandlerType; +} + +} // namespace res_handler diff --git a/src/res-copy/src/event_signal_sender.cc b/src/res-copy/src/event_signal_sender.cc new file mode 100644 index 0000000..332ca27 --- /dev/null +++ b/src/res-copy/src/event_signal_sender.cc @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/event_signal_sender.hh" + +#include +#include + +#include "include/error_type.hh" +#include "include/request_type.hh" + +namespace res_handler { + +bool EventSignalSender::SendStart() { + std::cout << "EventSignalSender::SendStart" << std::endl; + + return true; +} + +bool EventSignalSender::SendOK() { + std::cout << "EventSignalSender::SendOK" << std::endl; + + return true; +} + +bool EventSignalSender::SendFail(ErrorType error) { + std::cout << "EventSignalSender::SendFail" << std::endl; + + return true; +} + +void EventSignalSender::SetPkgID(std::string pkgid) { + pkgid_ = pkgid; +} + +void EventSignalSender::SetReqType(ReqType req_type) { + req_type_ = req_type; +} + +} // namespace res_handler diff --git a/src/res-copy/src/file_util.cc b/src/res-copy/src/file_util.cc new file mode 100644 index 0000000..87cf65d --- /dev/null +++ b/src/res-copy/src/file_util.cc @@ -0,0 +1,229 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/file_util.hh" + +#include +#include + +#include +#include +#include + +#include "include/logging.hh" + +namespace bs = boost::system; +namespace bf = boost::filesystem; + +namespace res_handler { + +FSFlag operator|(FSFlag a, FSFlag b) { + return static_cast(static_cast(a) | static_cast(b)); +} + +bool SetDirPermissions(const boost::filesystem::path& path, + boost::filesystem::perms permissions) { + boost::system::error_code error; + bf::permissions(path, permissions, error); + + if (error) { + LOG(ERROR) << "Failed to set permissions for directory: " << path + << boost::system::system_error(error).what(); + return false; + } + return true; +} + +bool SetOwnership(const bf::path& path, uid_t uid, gid_t gid) { + int ret = lchown(path.c_str(), uid, gid); + if (ret != 0) { + LOG(ERROR) << "Failed to change owner of: " << path; + return false; + } + return true; +} + +bool SetDirOwnershipAndPermissions(const boost::filesystem::path& path, + boost::filesystem::perms permissions, uid_t uid, + gid_t gid) { + if (!SetOwnership(path, uid, gid)) { + LOG(ERROR) << "Failed to change owner: " << path + << "(" << uid << ", " << gid << ")"; + return false; + } + if (!SetDirPermissions(path, permissions)) { + LOG(ERROR) << "Failed to change permission: " << path + << std::oct << permissions; + return false; + } + + return true; +} + +bool CopyOwnershipAndPermissions(const boost::filesystem::path& src, + const boost::filesystem::path& dst) { + if (!bf::exists(src)) { + LOG(ERROR) << "Failed to copy ownership and permissions" + << " from " << src << " to " << dst; + return false; + } + bf::perms permissions = bf::status(src).permissions(); + struct stat stats; + if (stat(src.c_str(), &stats) != 0) + return false; + if (!SetDirOwnershipAndPermissions(dst, permissions, stats.st_uid, + stats.st_gid)) { + LOG(ERROR) << "Failed to copy ownership and permissions" + << " from " << src << " to " << dst; + return false; + } + return true; +} + +bool RemoveAll(const bf::path& path) { + if (!exists(path) && !bf::is_symlink(bf::symlink_status(path))) + return true; + + bs::error_code error; + bf::remove_all(path, error); + + if (error) { + LOG(ERROR) << "Cannot remove: " << path << ", " << error.message(); + return false; + } + + return true; +} + +bool CopyDir(const boost::filesystem::path& src, + const boost::filesystem::path& dst, + FSFlag flags, bool skip_symlink) { + try { + // Check whether the function call is valid + if (!bf::exists(src) || !bf::is_directory(src)) { + LOG(ERROR) << "Source directory " << src + << " does not exist or is not a directory."; + return false; + } + if (!bf::exists(dst)) { + // Create the destination directory + if (!CreateDir(dst)) { + LOG(ERROR) << "Unable to create destination directory" << dst; + return false; + } + if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) + CopyOwnershipAndPermissions(src, dst); + } else { + if (!(flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE))) { + LOG(ERROR) << "Destination directory " << dst.string() + << " already exists."; + return false; + } + if (flags & (FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS)) + CopyOwnershipAndPermissions(src, dst); + } + } catch (const bf::filesystem_error& error) { + LOG(ERROR) << "Failed to copy directory: " << error.what(); + return false; + } + + // Iterate through the source directory + for (bf::directory_iterator file(src); + file != bf::directory_iterator(); + ++file) { + try { + bf::path current(file->path()); + bf::path target = dst / current.filename(); + + if (bf::is_symlink(symlink_status(current))) { + if (skip_symlink) + continue; + if ((flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE)) && + bf::exists(target)) + continue; + bs::error_code error; + bf::copy_symlink(current, target, error); + if (error) { + LOG(ERROR) << "Failed to copy symlink: " << current << ", " + << error.message(); + return false; + } + } else if (bf::is_directory(current)) { + // Found directory: Recursion + if (!CopyDir(current, target, flags, skip_symlink)) { + return false; + } + } else { + if ((flags & FS_MERGE_SKIP) && bf::exists(target)) + continue; + bf::path destination = target; + + if (flags & FS_COMMIT_COPY_FILE) + destination = + bf::unique_path(target.parent_path() / "%%%%-%%%%-%%%%-%%%%"); + + if (flags & FS_MERGE_OVERWRITE) + bf::copy_file(current, destination, + bf::copy_option::overwrite_if_exists); + else + bf::copy_file(current, destination); + + if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) + CopyOwnershipAndPermissions(current, destination); + + if (flags & FS_COMMIT_COPY_FILE) { + if (flags & FS_MERGE_OVERWRITE) + bf::remove(target); + bf::rename(destination, target); + } + } + } catch (const bf::filesystem_error& error) { + LOG(ERROR) << "Failed to copy directory: " << error.what(); + return false; + } + } + return true; +} + +bool CreateDir(const bf::path& path) { + if (bf::exists(path)) + return true; + + boost::system::error_code error; + bf::create_directories(path, error); + + if (error) { + LOG(ERROR) << "Failed to create directory: " + << boost::system::system_error(error).what(); + return false; + } + return true; +} + +bool CopyFile(const bf::path& src, const bf::path& dst) { + bs::error_code error; + + bf::copy_file(src, dst, bf::copy_option::overwrite_if_exists, error); + if (error) { + LOG(WARNING) << "copy file " << src << " due to error [" + << error.message() << "]"; + return false; + } + return true; +} + +} // namespace res_handler diff --git a/src/res-copy/src/logging.cc b/src/res-copy/src/logging.cc new file mode 100644 index 0000000..39bb6bc --- /dev/null +++ b/src/res-copy/src/logging.cc @@ -0,0 +1,24 @@ +// Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved +// Use of this source code is governed by a apache 2.0 license that can be +// found in the LICENSE file. + +#include "include/logging.hh" + +namespace utils { + +log_priority LogLevelToPriority(LogLevel level) { + switch (level) { + case LogLevel::LOG_ERROR: + return log_priority::DLOG_ERROR; + case LogLevel::LOG_WARNING: + return log_priority::DLOG_WARN; + case LogLevel::LOG_INFO: + return log_priority::DLOG_INFO; + case LogLevel::LOG_DEBUG: + return log_priority::DLOG_DEBUG; + default: + return log_priority::DLOG_UNKNOWN; + } +} + +} // namespace utils diff --git a/src/res-copy/src/param_checker.cc b/src/res-copy/src/param_checker.cc new file mode 100644 index 0000000..259974a --- /dev/null +++ b/src/res-copy/src/param_checker.cc @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/param_checker.hh" + +#include +#include +#include +#include +#include + +#include "include/logging.hh" +#include "include/request_type.hh" +#include "include/res_path_info.hh" + +#include + +#include +#include + +namespace bs = boost::system; +namespace bpo = boost::program_options; + +namespace res_handler { + +ParamChecker::ParamChecker(int argc, char* argv[]) { + bpo::options_description options; + + options.add_options() + ("uid,u", bpo::value()->default_value(0), "user id") + ("session-id,k", bpo::value(), "session id") + ("path,p", bpo::value>()->multitoken(), + "source-destination path") + ("remove,r", bpo::value(), "remove shared resource") + ("delete,d", bpo::value(), + "delete shared resource for package") + ("copy,c", bpo::value(), "copy resource") + ("help,h", "Show this message"); + + bpo::parsed_options parsed_options = bpo::command_line_parser(argc, argv) + .options(options) + .run(); + + for (const bpo::option& o : parsed_options.options) { + if (o.string_key == "uid") { + uid_ = static_cast(std::stoi(o.value.front())); + } else if (o.string_key == "session-id") { + session_id_ = o.value.front(); + } else if (o.string_key == "path") { + if (o.value.front() == o.value.back()) + path_info_list_.emplace_back(o.value.front(), ""); + else + path_info_list_.emplace_back(o.value.front(), o.value.back()); + } else if (o.string_key == "copy" || + o.string_key == "delete" || + o.string_key == "remove") { + pkgid_ = o.value.front(); + SetRequestType(o.string_key); + } else if (o.string_key == "help") { + std::cout << options; + } else { + std::cout << "Invalid option : " << o.string_key << std::endl; + } + } +} + +std::string ParamChecker::GetPkgID() const { + return pkgid_; +} + +uid_t ParamChecker::GetUID() const { + return uid_; +} + +ReqType ParamChecker::GetRequestType() { + return req_type_; +} + +const std::list& ParamChecker::GetPathList() const { + return path_info_list_; +} + +bool ParamChecker::Validate() { + if (uid_ == 0) { + LOG(ERROR) << "Invalid uid: " << uid_; + return false; + } + + if (req_type_ == ReqType::REQ_TYPE_UNKNOWN) { + LOG(ERROR) << "Invalid request type"; + return false; + } + + if (!ValidatePkgID()) + return false; + + if (req_type_ != ReqType::REQ_TYPE_UNINSTALL) { + if (path_info_list_.size() == 0) { + LOG(ERROR) << "Path is not given"; + return false; + } + } + + return true; +} + +void ParamChecker::SetRequestType(std::string key) { + if (key == "copy") + req_type_ = ReqType::REQ_TYPE_NEW; + else if (key == "remove") + req_type_ = ReqType::REQ_TYPE_REMOVE; + else if (key == "delete") + req_type_ = ReqType::REQ_TYPE_UNINSTALL; +} + +bool ParamChecker::ValidatePkgID() { + if (pkgid_.size() == 0) { + LOG(ERROR) << "pkgid is empty"; + return false; + } + + return true; +} + +} // namespace res_handler diff --git a/src/res-copy/src/remove_request_handler.cc b/src/res-copy/src/remove_request_handler.cc new file mode 100644 index 0000000..b6fdb74 --- /dev/null +++ b/src/res-copy/src/remove_request_handler.cc @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/remove_request_handler.hh" + +#include +#include + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/error_type.hh" +#include "include/file_util.hh" +#include "include/logging.hh" +#include "include/res_path_info.hh" + +namespace bf = boost::filesystem; + +namespace { + +constexpr char kRemoveReqHandlerType[] = "remove"; + +} // namespace + +namespace res_handler { + +RemoveRequestHandler::RemoveRequestHandler( + std::string pkgid, std::string root_path, + std::list path_list) : + AbstractRequestHandler(pkgid, root_path, path_list) {} + +ErrorType RemoveRequestHandler::Execute() { + bf::path root_path(GetRootPath()); + bf::path dst_root_path = root_path / "shared_res" / GetPkgID(); + + if (!bf::exists(dst_root_path)) { + LOG(ERROR) << "root path not exists"; + return ErrorType::ERROR_RES_NOT_FOUND; + } + + for (auto& path_info : GetPathList()) { + bf::path dst_path = dst_root_path / path_info.GetSrcPath(); + if (!bf::exists(dst_path)) { + LOG(ERROR) << "Path not exists: " << dst_path; + continue; + } + + if (!RemoveAll(dst_path)) + return ErrorType::ERROR_SYSTEM_ERROR; + } + + return ErrorType::ERROR_NONE; +} + +const std::string RemoveRequestHandler::GetRequestHandlerType() const { + return kRemoveReqHandlerType; +} + +} // namespace res_handler diff --git a/src/res-copy/src/request_handler_invoker.cc b/src/res-copy/src/request_handler_invoker.cc new file mode 100644 index 0000000..c8415a9 --- /dev/null +++ b/src/res-copy/src/request_handler_invoker.cc @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/request_handler_invoker.hh" + +#include + +#include + +#include "include/abstract_request_handler.hh" +#include "include/condition_validator.hh" +#include "include/copy_request_handler.hh" +#include "include/event_signal_sender.hh" +#include "include/logging.hh" +#include "include/param_checker.hh" +#include "include/remove_request_handler.hh" +#include "include/request_type.hh" +#include "include/uninstall_request_handler.hh" + +namespace { + +std::string GetRootPathForUid(uid_t uid) { + tzplatform_set_user(uid); + const char* rootpath = tzplatform_getenv(TZ_USER_HOME); + tzplatform_reset_user(); + return rootpath; +} + +} // namespace + +namespace res_handler { + +RequestHandlerInvoker::RequestHandlerInvoker( + ParamChecker option, EventSignalSender signal) : + option_(option), signal_(signal) { + SetReqHandler(); +} + +bool RequestHandlerInvoker::Validate() { + if (handler_ == nullptr) { + LOG(ERROR) << "Failed to initialize handler"; + return false; + } + + ConditionValidator validator(option_.GetPkgID(), option_.GetUID()); + if (validator.ValidateCondition( + option_.GetRequestType(), option_.GetPathList()) + != ErrorType::ERROR_NONE) { + LOG(ERROR) << "Validation failed"; + return false; + } + + return true; +} + +bool RequestHandlerInvoker::Execute() { + if (handler_ == nullptr) + return false; + + if (handler_->Execute() != ErrorType::ERROR_NONE) + return false; + + return true; +} + +const std::string RequestHandlerInvoker::GetHandlerType() const { + if (handler_ == nullptr) { + LOG(ERROR) << "handler has not initialized"; + return {}; + } + + return handler_->GetRequestHandlerType(); +} + +void RequestHandlerInvoker::SetReqHandler() { + switch (option_.GetRequestType()) { + case ReqType::REQ_TYPE_NEW: + handler_.reset( + new CopyRequestHandler( + option_.GetPkgID(), + GetRootPathForUid(option_.GetUID()), + option_.GetPathList())); + break; + case ReqType::REQ_TYPE_REMOVE: + + handler_.reset( + new RemoveRequestHandler( + option_.GetPkgID(), + GetRootPathForUid(option_.GetUID()), + option_.GetPathList())); + break; + case ReqType::REQ_TYPE_UNINSTALL: + handler_.reset( + new UninstallRequestHandler( + option_.GetPkgID(), + GetRootPathForUid(option_.GetUID()), + option_.GetPathList())); + break; + default: + LOG(ERROR) << "Invalid request type"; + break; + } +} + +} // namespace res_handler diff --git a/src/res-copy/src/res_copy_main.cc b/src/res-copy/src/res_copy_main.cc new file mode 100644 index 0000000..e2f084d --- /dev/null +++ b/src/res-copy/src/res_copy_main.cc @@ -0,0 +1,40 @@ +/* + * 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. + */ + +#include + +#include "include/res_handler.hh" +#include "include/logging.hh" + +int main(int argc, char *argv[]) { + try { + res_handler::ResHandler handler; + if (!handler.Init(argc, argv)) { + LOG(ERROR) << "Failed to initliaze handler"; + return -1; + } + + if (!handler.Run()) { + LOG(ERROR) << "Failed to handle request"; + return -1; + } + } catch (...) { + LOG(ERROR) << "Exception occured"; + return -1; + } + + return 0; +} diff --git a/src/res-copy/src/res_handler.cc b/src/res-copy/src/res_handler.cc new file mode 100644 index 0000000..b15b030 --- /dev/null +++ b/src/res-copy/src/res_handler.cc @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/res_handler.hh" + +#include + +#include "include/event_signal_sender.hh" +#include "include/logging.hh" +#include "include/param_checker.hh" +#include "include/request_handler_invoker.hh" + +namespace res_handler { + +bool ResHandler::Init(int argc, char* argv[]) { + res_handler::ParamChecker option(argc, argv); + if (!option.Validate()) { + LOG(ERROR) << "Invalid argument has given"; + return false; + } + + res_handler::EventSignalSender signal; + signal.SetPkgID(option.GetPkgID()); + signal.SetReqType(option.GetRequestType()); + + handler_.reset(new res_handler::RequestHandlerInvoker(option, signal)); + if (!handler_->Validate()) { + LOG(ERROR) << "Failed to initialize request handler"; + return false; + } + + return true; +} + +bool ResHandler::Run() { + return handler_->Execute(); +} + +} // namespace res_handler diff --git a/src/res-copy/src/res_path_info.cc b/src/res-copy/src/res_path_info.cc new file mode 100644 index 0000000..56e07df --- /dev/null +++ b/src/res-copy/src/res_path_info.cc @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/res_path_info.hh" + +#include +#include + +namespace res_handler { + +ResPathInfo::ResPathInfo(std::string src, std::string dst) : + src_(src), dst_(dst) {} + +const std::string& ResPathInfo::GetSrcPath() const { + return src_; +} + +const std::string& ResPathInfo::GetDstPath() const { + return dst_; +} + +} // namespace res_handler diff --git a/src/res-copy/src/uninstall_request_handler.cc b/src/res-copy/src/uninstall_request_handler.cc new file mode 100644 index 0000000..6655f1a --- /dev/null +++ b/src/res-copy/src/uninstall_request_handler.cc @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 "include/uninstall_request_handler.hh" + +#include +#include + +#include "include/abstract_request_handler.hh" +#include "include/error_type.hh" +#include "include/file_util.hh" +#include "include/logging.hh" +#include "include/res_path_info.hh" + +namespace bf = boost::filesystem; + +namespace { + +constexpr char kUninstallReqHandlerType[] = "delete"; + +} // namespace + +namespace res_handler { + +UninstallRequestHandler::UninstallRequestHandler( + std::string pkgid, std::string root_path, + std::list path_list) : + AbstractRequestHandler(pkgid, root_path, path_list) {} + +ErrorType UninstallRequestHandler::Execute() { + if (GetPkgID().length() == 0) { + LOG(ERROR) << "Invalid argument"; + return ErrorType::ERROR_INVALID_PARAMETER; + } + + bf::path root_path(GetRootPath()); + root_path = root_path / "shared_res" / GetPkgID(); + + if (!bf::exists(root_path)) { + LOG(WARNING) << "path not exists : " << root_path; + return ErrorType::ERROR_NONE; + } + + if (!RemoveAll(root_path)) + return ErrorType::ERROR_SYSTEM_ERROR; + + return ErrorType::ERROR_NONE; +} + +const std::string UninstallRequestHandler::GetRequestHandlerType() const { + return kUninstallReqHandlerType; +} + +} // namespace res_handler diff --git a/src/rsc-copy/CMakeLists.txt b/src/rsc-copy/CMakeLists.txt deleted file mode 100644 index 56bc952..0000000 --- a/src/rsc-copy/CMakeLists.txt +++ /dev/null @@ -1,19 +0,0 @@ -# Target - sources -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRCS) -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include) - -# Target - definition -ADD_EXECUTABLE(${TARGET_RSC_COPY} ${SRCS}) - -# Dependency -APPLY_PKG_CONFIG(${TARGET_RSC_COPY} PUBLIC - AUL_DEPS - GLIB_DEPS - BUNDLE_DEPS - Boost - PKGMGR_INFO_DEPS - TZPLATFORM_DEPS -) - -# Install -INSTALL(TARGETS ${TARGET_RSC_COPY} DESTINATION bin) \ No newline at end of file diff --git a/src/rsc-copy/include/abstract_request_handler.hh b/src/rsc-copy/include/abstract_request_handler.hh deleted file mode 100644 index 8cb8fd1..0000000 --- a/src/rsc-copy/include/abstract_request_handler.hh +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 ABSTRACT_REQUEST_HANDLER_HH_ -#define ABSTRACT_REQUEST_HANDLER_HH_ - -#include -#include - -#include "include/error_type.hh" -#include "include/rsc_path_info.hh" - -namespace rsc_handler { - -class AbstractRequestHandler { - public: - AbstractRequestHandler( - std::string pkgid, std::string root_path, std::list path_list) : - pkgid_(pkgid), root_path_(root_path), path_list_(path_list) {}; - - virtual ErrorType Execute() = 0; - virtual const std::string GetRequestHandlerType() const = 0; - - protected: - std::string GetRootPath(); - const std::string GetPkgID() const; - const std::list GetPathList() const; - - private: - std::string pkgid_; - std::string root_path_; - std::list path_list_; -}; - -} // rsc_handler - -#endif // ABSTRACT_REQUEST_HANDLER_HH_ diff --git a/src/rsc-copy/include/condition_validator.hh b/src/rsc-copy/include/condition_validator.hh deleted file mode 100644 index 6a1d451..0000000 --- a/src/rsc-copy/include/condition_validator.hh +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 CONDITION_VALIDATOR_HH_ -#define CONDITION_VALIDATOR_HH_ - -#include -#include - -#include "include/error_type.hh" -#include "include/rsc_path_info.hh" -#include "include/request_type.hh" - -namespace rsc_handler { - -class ConditionValidator { - public: - ConditionValidator(std::string pkgid, uid_t uid); - ErrorType ValidateCondition(ReqType req_type, - std::list path_list); - - private: - std::string pkgid_; - std::string root_path_; - uid_t uid_; - - ErrorType CheckCopyRequest(std::list path_list); - ErrorType CheckRemoveRequest(std::list path_list); -}; - -} // namespace rsc_handler - -#endif // CONDITION_VALIDATOR_HH_ diff --git a/src/rsc-copy/include/copy_request_handler.hh b/src/rsc-copy/include/copy_request_handler.hh deleted file mode 100644 index c723929..0000000 --- a/src/rsc-copy/include/copy_request_handler.hh +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 COPY_REQUEST_HANDLER_HH_ -#define COPY_REQUEST_HANDLER_HH_ - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/error_type.hh" -#include "include/rsc_path_info.hh" - -namespace rsc_handler { - -class CopyRequestHandler : public AbstractRequestHandler { - public: - CopyRequestHandler(std::string pkgid, std::string root_path, - std::list path_list); - - ErrorType Execute() override; - const std::string GetRequestHandlerType() const override; -}; - -} // namespace rsc_handler - -#endif // COPY_REQUEST_HANDLER_HH_ diff --git a/src/rsc-copy/include/error_type.hh b/src/rsc-copy/include/error_type.hh deleted file mode 100644 index df9701d..0000000 --- a/src/rsc-copy/include/error_type.hh +++ /dev/null @@ -1,35 +0,0 @@ -/* - * 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 ERROR_TYPE_HH_ -#define ERROR_TYPE_HH_ - -namespace rsc_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 -}; - -} // namespace rsc_handler - -#endif // ERROR_TYPE_HH_ diff --git a/src/rsc-copy/include/event_signal_sender.hh b/src/rsc-copy/include/event_signal_sender.hh deleted file mode 100644 index 3e42451..0000000 --- a/src/rsc-copy/include/event_signal_sender.hh +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 EVENT_SIGNAL_SENDER_HH_ -#define EVENT_SIGNAL_SENDER_HH_ - -#include - -#include "include/error_type.hh" -#include "include/request_type.hh" - -namespace rsc_handler { - -class EventSignalSender { - public: - EventSignalSender() : pkgid_(""), req_type_(ReqType::REQ_TYPE_UNKNOWN) {}; - bool SendStart(); - bool SendOK(); - bool SendFail(ErrorType error); - void SetPkgID(std::string pkgid); - void SetReqType(ReqType req_type); - - private: - std::string pkgid_; - ReqType req_type_; -}; - -} // rsc_handler - -#endif // PARAM_CHECKER_HH_ diff --git a/src/rsc-copy/include/file_util.hh b/src/rsc-copy/include/file_util.hh deleted file mode 100644 index 0e6d431..0000000 --- a/src/rsc-copy/include/file_util.hh +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 FILE_UTIL_HH_ -#define FILE_UTIL_HH_ - -#include -#include - -namespace rsc_handler { - -// TODO(jungh.yeon) : is this necessary? -enum FSFlag : int { - FS_NONE = 0, - FS_MERGE_SKIP = (1 << 0), - FS_MERGE_OVERWRITE = (1 << 1), - FS_COMMIT_COPY_FILE = (1 << 2), - FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS = (1 << 3) -}; - -FSFlag operator|(FSFlag a, FSFlag b); - -bool CreateDir(const boost::filesystem::path& path); - -bool CopyDir(const boost::filesystem::path& src, - const boost::filesystem::path& dst, - FSFlag flags = FS_NONE, bool skip_symlink = false); - -bool CopyFile(const boost::filesystem::path& src, - const boost::filesystem::path& dst); - -bool RemoveAll(const boost::filesystem::path& path); - -} // namespace rsc_handler - -#endif // FILE_UTIL_HH_ diff --git a/src/rsc-copy/include/logging.hh b/src/rsc-copy/include/logging.hh deleted file mode 100644 index 814e875..0000000 --- a/src/rsc-copy/include/logging.hh +++ /dev/null @@ -1,180 +0,0 @@ -// Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved -// Use of this source code is governed by a apache 2.0 license that can be -// found in the LICENSE file. - -#ifndef LOGGING_HH_ -#define LOGGING_HH_ - -#include - -#ifndef PROJECT_TAG -#define PROJECT_TAG "PKGMGR_TOOL" -#endif - -#ifdef LOG -#undef LOG -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef __FILENAME__ -#define __FILENAME__ \ - (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) -#endif - -namespace utils { - -enum class LogLevel { - LOG_ERROR, - LOG_WARNING, - LOG_INFO, - LOG_DEBUG, -}; - -log_priority LogLevelToPriority(LogLevel level); - -template struct LogTag; -template<> struct LogTag { - static constexpr const char* value = "\033[1;31m| ERROR |\033[0m"; -}; -template<> struct LogTag { - static constexpr const char* value = "\033[1;33m| WARNING |\033[0m"; -}; -template<> struct LogTag { - static constexpr const char* value = "\033[1;32m| INFO |\033[0m"; -}; -template<> struct LogTag { - static constexpr const char* value = "\033[0m| DEBUG |\033[0m"; -}; - -template > -class StringStream : private std::basic_ostringstream { - public: - using std::basic_ostringstream::str; - - template - StringStream& operator<<(const T& value) { - static_cast &>(*this) << value; - return *this; - } -}; - -// Interface class for logging backends. The custom LogBackend which wants -// log using LOG() macro should be implement following interface. -class ILogBackend { - public: - virtual void WriteLog(LogLevel level, const std::string& tag, - const std::string& logstr) = 0; -}; - -class DLogBackend : public ILogBackend { - public: - void WriteLog(LogLevel level, const std::string& tag, - const std::string& logstr) override { - dlog_print(LogLevelToPriority(level), tag.c_str(), "%s", - Escape(logstr).c_str()); - } - - private: - // Since LogCatcher passes input to dlog_print(), the input which contains - // format string(such as %d, %n) can cause unexpected result. - // This is simple function to escape '%'. - // NOTE: Is there any gorgeous way instead of this? - std::string Escape(const std::string& str) const { - std::string escaped = std::string(str); - size_t start_pos = 0; - std::string from = "%"; - std::string to = "%%"; - while ((start_pos = escaped.find(from, start_pos)) != std::string::npos) { - escaped.replace(start_pos, from.length(), to); - start_pos += to.length(); - } - return escaped; - } -}; - -class LogCore { - public: - // Do not call this function at destructor of global object - static LogCore& GetCore() { - static LogCore core; - return core; - } - - void AddLogBackend(std::shared_ptr backend) { - backend_list_.emplace_back(backend); - } - - void Log(LogLevel level, const std::string& tag, const std::string& log) { - for (auto& backend : backend_list_) - backend->WriteLog(level, tag, log); - } - - private: - LogCore() { - // add default dlog backend - AddLogBackend(std::shared_ptr(new DLogBackend())); - } - ~LogCore() = default; - LogCore(const LogCore&) = delete; - LogCore& operator=(const LogCore&) = delete; - - std::vector> backend_list_; -}; - -class LogCatcher { - public: - LogCatcher(LogLevel level, const char* tag) - : level_(level), tag_(tag) { } - - void operator&(const StringStream& str) const { - LogCore::GetCore().Log(level_, tag_, str.str()); - } - - private: - LogLevel level_; - std::string tag_; -}; - -} // namespace utils - - -inline static const constexpr char* __tag_for_logging() { - return ""; -} - -inline static const constexpr char* __tag_for_project() { - return PROJECT_TAG; -} - -// To be defined in class namespace if user want different log tag for given -// scope -#define SCOPE_LOG_TAG(TAG) \ - inline static const constexpr char* __tag_for_logging() { \ - return #TAG; \ - } \ - -// Simple logging macro of following usage: -// LOG(LEVEL) << object_1 << object_2 << object_n; -// where: -// LEVEL = ERROR | WARNING | INFO | DEBUG -#define LOG(LEVEL) \ - ::utils::LogCatcher( \ - ::utils::LogLevel::LOG_ ## LEVEL, __tag_for_project()) \ - & ::utils::StringStream() \ - << std::string(::utils::LogTag<::utils::LogLevel::LOG_ ## LEVEL>::value) \ - << " " << std::setw(25) << std::left << __tag_for_logging() \ - << " : " << std::setw(36) \ - << (std::string(__FILENAME__) + ":" + std::to_string(__LINE__)).c_str() \ - << std::setw(0) << " : " \ - -#endif // LOGGING_HH_ diff --git a/src/rsc-copy/include/param_checker.hh b/src/rsc-copy/include/param_checker.hh deleted file mode 100644 index 4e66107..0000000 --- a/src/rsc-copy/include/param_checker.hh +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 PARAM_CHECKER_HH_ -#define PARAM_CHECKER_HH_ - -#include -#include - -#include "include/request_type.hh" -#include "include/rsc_path_info.hh" - -namespace rsc_handler { - -class ParamChecker { - public: - ParamChecker(int argc, char* argv[]); - ReqType GetRequestType(); - std::string GetPkgID() const; - uid_t GetUID() const; - const std::list& GetPathList() const; - bool Validate(); - - private: - std::list path_info_list_; - std::string pkgid_; - std::string session_id_; - uid_t uid_ = 0; - ReqType req_type_ = ReqType::REQ_TYPE_UNKNOWN; - - void SetRequestType(std::string key); - bool ValidatePkgID(); -}; - -} // rsc_handler - -#endif // PARAM_CHECKER_HH_ diff --git a/src/rsc-copy/include/remove_request_handler.hh b/src/rsc-copy/include/remove_request_handler.hh deleted file mode 100644 index 35469f6..0000000 --- a/src/rsc-copy/include/remove_request_handler.hh +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 REMOVE_REQUEST_HANDLER_HH_ -#define REMOVE_REQUEST_HANDLER_HH_ - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/error_type.hh" -#include "include/rsc_path_info.hh" - -namespace rsc_handler { - -class RemoveRequestHandler : public AbstractRequestHandler { - public: - RemoveRequestHandler( - std::string pkgid, std::string root_path, - std::list path_list); - - ErrorType Execute() override; - const std::string GetRequestHandlerType() const override; -}; - -} // namespace rsc_handler - -#endif // REMOVE_REQUEST_HANDLER_HH_ diff --git a/src/rsc-copy/include/request_handler_invoker.hh b/src/rsc-copy/include/request_handler_invoker.hh deleted file mode 100644 index 0098aea..0000000 --- a/src/rsc-copy/include/request_handler_invoker.hh +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 REQUEST_HANDLER_INVOKER_HH_ -#define REQUEST_HANDLER_INVOKER_HH_ - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/event_signal_sender.hh" -#include "include/param_checker.hh" - -namespace rsc_handler { - -class RequestHandlerInvoker { - public: - RequestHandlerInvoker(ParamChecker option, EventSignalSender signal); - - bool Validate(); - bool Execute(); - const std::string GetHandlerType() const; - - private: - std::unique_ptr handler_; - ParamChecker option_; - EventSignalSender signal_; - - void SetReqHandler(); -}; - -} // rsc_handler - -#endif // REQUEST_HANDLER_INVOKER_HH_ diff --git a/src/rsc-copy/include/request_type.hh b/src/rsc-copy/include/request_type.hh deleted file mode 100644 index dbd5022..0000000 --- a/src/rsc-copy/include/request_type.hh +++ /dev/null @@ -1,31 +0,0 @@ -/* - * 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 REQUEST_TYPE_HH_ -#define REQUEST_TYPE_HH_ - -namespace rsc_handler { - -enum ReqType { - REQ_TYPE_NEW = 0, - REQ_TYPE_REMOVE = 1, - REQ_TYPE_UNINSTALL, - REQ_TYPE_UNKNOWN -}; - -} // namespace rsc_handler - -#endif // REQUEST_TYPE_HH_ diff --git a/src/rsc-copy/include/rsc_handler.hh b/src/rsc-copy/include/rsc_handler.hh deleted file mode 100644 index 9eeb314..0000000 --- a/src/rsc-copy/include/rsc_handler.hh +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 RSC_HANDLER_HH_ -#define RSC_HANDLER_HH_ - -#include - -#include "include/request_handler_invoker.hh" - -namespace rsc_handler { - -class RscHandler { - public: - RscHandler() {}; - //~RscHandler(); - bool Init(int argc, char* argv[]); - bool Run(); - - private: - std::unique_ptr handler_; -}; - -} // rsc_handler - -#endif // RSC_HANDLER_HH_ diff --git a/src/rsc-copy/include/rsc_path_info.hh b/src/rsc-copy/include/rsc_path_info.hh deleted file mode 100644 index 089bb84..0000000 --- a/src/rsc-copy/include/rsc_path_info.hh +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 RSC_PATH_INFO_HH_ -#define RSC_PATH_INFO_HH_ - -#include - -namespace rsc_handler { - -class RscPathInfo { - public: - RscPathInfo(std::string src, std::string dst); - - const std::string& GetSrcPath() const; - const std::string& GetDstPath() const; - - private: - std::string src_; - std::string dst_; -}; - -} // rsc_handler - -#endif // RSC_PATH_INFO_HH_ diff --git a/src/rsc-copy/include/uninstall_request_handler.hh b/src/rsc-copy/include/uninstall_request_handler.hh deleted file mode 100644 index 4e9627a..0000000 --- a/src/rsc-copy/include/uninstall_request_handler.hh +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 UNINSTALL_REQUEST_HANDLER_HH_ -#define UNINSTALL_REQUEST_HANDLER_HH_ - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/error_type.hh" -#include "include/rsc_path_info.hh" - -namespace rsc_handler { - -class UninstallRequestHandler : public AbstractRequestHandler { - public: - UninstallRequestHandler( - std::string pkgid, std::string root_path, std::list path_list); - - ErrorType Execute() override; - const std::string GetRequestHandlerType() const override; -}; - -} // namespace rsc_handler - -#endif // UNINSTALL_REQUEST_HANDLER_HH_ diff --git a/src/rsc-copy/src/abstract_request_handler.cc b/src/rsc-copy/src/abstract_request_handler.cc deleted file mode 100644 index d35bea0..0000000 --- a/src/rsc-copy/src/abstract_request_handler.cc +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/abstract_request_handler.hh" - -#include - -#include "include/request_type.hh" -#include "include/rsc_path_info.hh" - -namespace rsc_handler { - -std::string AbstractRequestHandler::GetRootPath() { - return root_path_; -} - -const std::string AbstractRequestHandler::GetPkgID() const { - return pkgid_; -} - -const std::list AbstractRequestHandler::GetPathList() const { - return path_list_; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/condition_validator.cc b/src/rsc-copy/src/condition_validator.cc deleted file mode 100644 index 46b2315..0000000 --- a/src/rsc-copy/src/condition_validator.cc +++ /dev/null @@ -1,181 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/condition_validator.hh" - -#include -#include -#include -#include - -#include - -#include -#include -#include - -#include "include/logging.hh" -#include "include/request_type.hh" -#include "include/rsc_path_info.hh" - -#include - -namespace bf = boost::filesystem; - -namespace { - -std::string GetRootPath(uid_t uid) { - tzplatform_set_user(uid); - const char* rootpath = tzplatform_getenv(TZ_USER_HOME); - tzplatform_reset_user(); - return rootpath; -} - -bool IsPackageExists(std::string pkgid, uid_t uid) { - pkgmgrinfo_pkginfo_h handle; - if (pkgmgrinfo_pkginfo_get_usr_pkginfo( - pkgid.c_str(), uid, &handle) != PMINFO_R_OK) { - LOG(ERROR) << "package not exists : " << pkgid; - return false; - } - pkgmgrinfo_pkginfo_destroy_pkginfo(handle); - - return true; -} - -bool CheckFreeSpaceAtPath(int64_t required_size, - const bf::path& target_location) { - boost::system::error_code error; - bf::path root = target_location; - - while (!bf::exists(root) && root != root.root_path()) - root = root.parent_path(); - - if (!bf::exists(root)) { - LOG(ERROR) << "No mount point for path: " << target_location; - return false; - } - - bf::space_info space_info = bf::space(root, error); - if (error) { - LOG(ERROR) << "Failed to get space_info: " << error.message(); - return false; - } - - return (space_info.free >= static_cast(required_size)); -} - -int64_t GetBlockSizeForPath(const bf::path& path_in_partition) { - struct stat stats; - if (stat(path_in_partition.string().c_str(), &stats)) { - LOG(ERROR) << "stat(" << path_in_partition.string() - << ") failed - error code: " << errno; - return -1; - } - return stats.st_blksize; -} - -int64_t RoundUpToBlockSizeOf(int64_t size, int64_t block_size) { - return ((size + block_size - 1) / block_size) * block_size; -} - -int64_t GetDirectorySize(const bf::path& path) { - int64_t block_size = GetBlockSizeForPath(path); - - if (block_size == -1) - return -1; - - int64_t size = 0; - for (bf::recursive_directory_iterator iter(path); - iter != bf::recursive_directory_iterator(); ++iter) { - struct stat buf; - if (lstat(iter->path().c_str(), &buf) == -1) { - LOG(ERROR) << "lstat() failed for: " << iter->path(); - return -1; - } - size += RoundUpToBlockSizeOf(buf.st_size, block_size); - } - - return size; -} - -} // namespace - -namespace rsc_handler { - -ConditionValidator::ConditionValidator(std::string pkgid, uid_t uid) : - pkgid_(pkgid), uid_(uid) { - root_path_ = GetRootPath(uid_); -} - -ErrorType ConditionValidator::ValidateCondition(ReqType req_type, - std::list path_list) { - if (!IsPackageExists(pkgid_, uid_)) - return ErrorType::ERROR_PKG_NOT_FOUND; - - if (req_type == ReqType::REQ_TYPE_NEW) - return CheckCopyRequest(path_list); - else if (req_type == ReqType::REQ_TYPE_REMOVE) - return CheckRemoveRequest(path_list); - - return ErrorType::ERROR_NONE; -} - -ErrorType ConditionValidator::CheckCopyRequest( - std::list path_list) { - boost::filesystem::path src_root_path(root_path_); - uintmax_t rsc_size = 0; - - src_root_path = src_root_path / "apps_rw" / pkgid_; - for (auto& path_info : path_list) { - boost::filesystem::path rsc_path(src_root_path); - rsc_path = rsc_path / path_info.GetSrcPath(); - if (!boost::filesystem::exists(rsc_path)) { - LOG(ERROR) << "Resource not exists : " << rsc_path; - return ErrorType::ERROR_RES_NOT_FOUND; - } - - if (boost::filesystem::is_directory(rsc_path)) - rsc_size += GetDirectorySize(rsc_path); - else - rsc_size += boost::filesystem::file_size(rsc_path); - } - LOG(INFO) << "Required size for resource: " << rsc_size; - - if (!CheckFreeSpaceAtPath(static_cast(rsc_size), root_path_)) { - LOG(ERROR) << "Not enough space for resource"; - return ErrorType::ERROR_OUT_OF_SPACE; - } - - return ErrorType::ERROR_NONE; -} - -ErrorType ConditionValidator::CheckRemoveRequest( - std::list path_list) { - for (auto& path_info : path_list) { - boost::filesystem::path dst_path(root_path_); - dst_path = dst_path / "shared_res"/ pkgid_ / path_info.GetDstPath(); - if (!boost::filesystem::exists(dst_path)) { - LOG(ERROR) << "Resource not exists : " << dst_path; - return ErrorType::ERROR_RES_NOT_FOUND; - } - } - - return ErrorType::ERROR_NONE; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/copy_request_handler.cc b/src/rsc-copy/src/copy_request_handler.cc deleted file mode 100644 index b4ce458..0000000 --- a/src/rsc-copy/src/copy_request_handler.cc +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/copy_request_handler.hh" - -#include -#include - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/error_type.hh" -#include "include/file_util.hh" -#include "include/logging.hh" -#include "include/rsc_path_info.hh" - -namespace bf = boost::filesystem; - -namespace { - -constexpr char kCopyReqHandlerType[] = "copy"; - -} // namespace - -namespace rsc_handler { - -CopyRequestHandler::CopyRequestHandler( - std::string pkgid, std::string root_path, - std::list path_list) : - AbstractRequestHandler(pkgid, root_path, path_list) {} - -ErrorType CopyRequestHandler::Execute() { - bf::path root_path(GetRootPath()); - bf::path src_root_path = root_path / "apps_rw" / GetPkgID(); - bf::path dst_root_path = root_path / "shared_res" / GetPkgID(); - - if (!CreateDir(dst_root_path)) - return ErrorType::ERROR_SYSTEM_ERROR; - - for (auto& path_info : GetPathList()) { - bf::path src_path = src_root_path / path_info.GetSrcPath(); - if (!bf::exists(src_path)) { - LOG(ERROR) << "Path not exists :" << src_path; - return ErrorType::ERROR_RES_NOT_FOUND; - } - - bf::path dst_path = dst_root_path / path_info.GetDstPath(); - - if (bf::is_directory(src_path)) { - if (!CopyDir(src_path, dst_path, - FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS, true)) { - LOG(ERROR) << "Failed to copy directory " << src_path; - return ErrorType::ERROR_SYSTEM_ERROR; - } - } else { - if (bf::is_directory(dst_path)) - dst_path /= src_path.filename(); - - if (!CopyFile(src_path, dst_path)) { - LOG(ERROR) << "Failed to copy directory " << src_path; - return ErrorType::ERROR_SYSTEM_ERROR; - } - } - } - - return ErrorType::ERROR_NONE; -} - -const std::string CopyRequestHandler::GetRequestHandlerType() const { - return kCopyReqHandlerType; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/event_signal_sender.cc b/src/rsc-copy/src/event_signal_sender.cc deleted file mode 100644 index 81fbafe..0000000 --- a/src/rsc-copy/src/event_signal_sender.cc +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/event_signal_sender.hh" - -#include -#include - -#include "include/error_type.hh" -#include "include/request_type.hh" - -namespace rsc_handler { - -bool EventSignalSender::SendStart() { - std::cout << "EventSignalSender::SendStart" << std::endl; - - return true; -} - -bool EventSignalSender::SendOK() { - std::cout << "EventSignalSender::SendOK" << std::endl; - - return true; -} - -bool EventSignalSender::SendFail(ErrorType error) { - std::cout << "EventSignalSender::SendFail" << std::endl; - - return true; -} - -void EventSignalSender::SetPkgID(std::string pkgid) { - pkgid_ = pkgid; -} - -void EventSignalSender::SetReqType(ReqType req_type) { - req_type_ = req_type; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/file_util.cc b/src/rsc-copy/src/file_util.cc deleted file mode 100644 index 322d034..0000000 --- a/src/rsc-copy/src/file_util.cc +++ /dev/null @@ -1,229 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/file_util.hh" - -#include -#include - -#include -#include -#include - -#include "include/logging.hh" - -namespace bs = boost::system; -namespace bf = boost::filesystem; - -namespace rsc_handler { - -FSFlag operator|(FSFlag a, FSFlag b) { - return static_cast(static_cast(a) | static_cast(b)); -} - -bool SetDirPermissions(const boost::filesystem::path& path, - boost::filesystem::perms permissions) { - boost::system::error_code error; - bf::permissions(path, permissions, error); - - if (error) { - LOG(ERROR) << "Failed to set permissions for directory: " << path - << boost::system::system_error(error).what(); - return false; - } - return true; -} - -bool SetOwnership(const bf::path& path, uid_t uid, gid_t gid) { - int ret = lchown(path.c_str(), uid, gid); - if (ret != 0) { - LOG(ERROR) << "Failed to change owner of: " << path; - return false; - } - return true; -} - -bool SetDirOwnershipAndPermissions(const boost::filesystem::path& path, - boost::filesystem::perms permissions, uid_t uid, - gid_t gid) { - if (!SetOwnership(path, uid, gid)) { - LOG(ERROR) << "Failed to change owner: " << path - << "(" << uid << ", " << gid << ")"; - return false; - } - if (!SetDirPermissions(path, permissions)) { - LOG(ERROR) << "Failed to change permission: " << path - << std::oct << permissions; - return false; - } - - return true; -} - -bool CopyOwnershipAndPermissions(const boost::filesystem::path& src, - const boost::filesystem::path& dst) { - if (!bf::exists(src)) { - LOG(ERROR) << "Failed to copy ownership and permissions" - << " from " << src << " to " << dst; - return false; - } - bf::perms permissions = bf::status(src).permissions(); - struct stat stats; - if (stat(src.c_str(), &stats) != 0) - return false; - if (!SetDirOwnershipAndPermissions(dst, permissions, stats.st_uid, - stats.st_gid)) { - LOG(ERROR) << "Failed to copy ownership and permissions" - << " from " << src << " to " << dst; - return false; - } - return true; -} - -bool RemoveAll(const bf::path& path) { - if (!exists(path) && !bf::is_symlink(bf::symlink_status(path))) - return true; - - bs::error_code error; - bf::remove_all(path, error); - - if (error) { - LOG(ERROR) << "Cannot remove: " << path << ", " << error.message(); - return false; - } - - return true; -} - -bool CopyDir(const boost::filesystem::path& src, - const boost::filesystem::path& dst, - FSFlag flags, bool skip_symlink) { - try { - // Check whether the function call is valid - if (!bf::exists(src) || !bf::is_directory(src)) { - LOG(ERROR) << "Source directory " << src - << " does not exist or is not a directory."; - return false; - } - if (!bf::exists(dst)) { - // Create the destination directory - if (!CreateDir(dst)) { - LOG(ERROR) << "Unable to create destination directory" << dst; - return false; - } - if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) - CopyOwnershipAndPermissions(src, dst); - } else { - if (!(flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE))) { - LOG(ERROR) << "Destination directory " << dst.string() - << " already exists."; - return false; - } - if (flags & (FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS)) - CopyOwnershipAndPermissions(src, dst); - } - } catch (const bf::filesystem_error& error) { - LOG(ERROR) << "Failed to copy directory: " << error.what(); - return false; - } - - // Iterate through the source directory - for (bf::directory_iterator file(src); - file != bf::directory_iterator(); - ++file) { - try { - bf::path current(file->path()); - bf::path target = dst / current.filename(); - - if (bf::is_symlink(symlink_status(current))) { - if (skip_symlink) - continue; - if ((flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE)) && - bf::exists(target)) - continue; - bs::error_code error; - bf::copy_symlink(current, target, error); - if (error) { - LOG(ERROR) << "Failed to copy symlink: " << current << ", " - << error.message(); - return false; - } - } else if (bf::is_directory(current)) { - // Found directory: Recursion - if (!CopyDir(current, target, flags, skip_symlink)) { - return false; - } - } else { - if ((flags & FS_MERGE_SKIP) && bf::exists(target)) - continue; - bf::path destination = target; - - if (flags & FS_COMMIT_COPY_FILE) - destination = - bf::unique_path(target.parent_path() / "%%%%-%%%%-%%%%-%%%%"); - - if (flags & FS_MERGE_OVERWRITE) - bf::copy_file(current, destination, - bf::copy_option::overwrite_if_exists); - else - bf::copy_file(current, destination); - - if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) - CopyOwnershipAndPermissions(current, destination); - - if (flags & FS_COMMIT_COPY_FILE) { - if (flags & FS_MERGE_OVERWRITE) - bf::remove(target); - bf::rename(destination, target); - } - } - } catch (const bf::filesystem_error& error) { - LOG(ERROR) << "Failed to copy directory: " << error.what(); - return false; - } - } - return true; -} - -bool CreateDir(const bf::path& path) { - if (bf::exists(path)) - return true; - - boost::system::error_code error; - bf::create_directories(path, error); - - if (error) { - LOG(ERROR) << "Failed to create directory: " - << boost::system::system_error(error).what(); - return false; - } - return true; -} - -bool CopyFile(const bf::path& src, const bf::path& dst) { - bs::error_code error; - - bf::copy_file(src, dst, bf::copy_option::overwrite_if_exists, error); - if (error) { - LOG(WARNING) << "copy file " << src << " due to error [" - << error.message() << "]"; - return false; - } - return true; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/logging.cc b/src/rsc-copy/src/logging.cc deleted file mode 100644 index 5e2a5d6..0000000 --- a/src/rsc-copy/src/logging.cc +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved -// Use of this source code is governed by a apache 2.0 license that can be -// found in the LICENSE file. - -#include "logging.hh" - -namespace utils { - -log_priority LogLevelToPriority(LogLevel level) { - switch (level) { - case LogLevel::LOG_ERROR: - return log_priority::DLOG_ERROR; - case LogLevel::LOG_WARNING: - return log_priority::DLOG_WARN; - case LogLevel::LOG_INFO: - return log_priority::DLOG_INFO; - case LogLevel::LOG_DEBUG: - return log_priority::DLOG_DEBUG; - default: - return log_priority::DLOG_UNKNOWN; - } -} - -} // namespace utils diff --git a/src/rsc-copy/src/param_checker.cc b/src/rsc-copy/src/param_checker.cc deleted file mode 100644 index f319715..0000000 --- a/src/rsc-copy/src/param_checker.cc +++ /dev/null @@ -1,139 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/param_checker.hh" - -#include -#include -#include -#include -#include - -#include "include/logging.hh" -#include "include/request_type.hh" -#include "include/rsc_path_info.hh" - -#include - -#include -#include - -namespace bs = boost::system; -namespace bpo = boost::program_options; - -namespace rsc_handler { - -ParamChecker::ParamChecker(int argc, char* argv[]) { - bpo::options_description options; - - options.add_options() - ("uid,u", bpo::value()->default_value(0), "user id") - ("session-id,k", bpo::value(), "session id") - ("path,p", bpo::value>()->multitoken(), - "source-destination path") - ("remove,r", bpo::value(), "remove shared resource") - ("delete,d", bpo::value(), - "delete shared resource for package") - ("copy,c", bpo::value(), "copy resource") - ("help,h", "Show this message"); - - bpo::parsed_options parsed_options = bpo::command_line_parser(argc, argv) - .options(options) - .run(); - - for (const bpo::option& o : parsed_options.options) { - if (o.string_key == "uid") { - uid_ = static_cast(std::stoi(o.value.front())); - } else if (o.string_key == "session-id") { - session_id_ = o.value.front(); - } else if (o.string_key == "path") { - if (o.value.front() == o.value.back()) - path_info_list_.emplace_back(o.value.front(), ""); - else - path_info_list_.emplace_back(o.value.front(), o.value.back()); - } else if (o.string_key == "copy" || - o.string_key == "delete" || - o.string_key == "remove") { - pkgid_ = o.value.front(); - SetRequestType(o.string_key); - } else if (o.string_key == "help") { - std::cout << options; - } else { - std::cout << "Invalid option : " << o.string_key << std::endl; - } - } -} - -std::string ParamChecker::GetPkgID() const { - return pkgid_; -} - -uid_t ParamChecker::GetUID() const { - return uid_; -} - -ReqType ParamChecker::GetRequestType() { - return req_type_; -} - -const std::list& ParamChecker::GetPathList() const { - return path_info_list_; -} - -bool ParamChecker::Validate() { - if (uid_ == 0) { - LOG(ERROR) << "Invalid uid: " << uid_; - return false; - } - - if (req_type_ == ReqType::REQ_TYPE_UNKNOWN) { - LOG(ERROR) << "Invalid request type"; - return false; - } - - if (!ValidatePkgID()) - return false; - - if (req_type_ != ReqType::REQ_TYPE_UNINSTALL) { - if (path_info_list_.size() == 0) { - LOG(ERROR) << "Path is not given"; - return false; - } - } - - return true; -} - -void ParamChecker::SetRequestType(std::string key) { - if (key == "copy") - req_type_ = ReqType::REQ_TYPE_NEW; - else if (key == "remove") - req_type_ = ReqType::REQ_TYPE_REMOVE; - else if (key == "delete") - req_type_ = ReqType::REQ_TYPE_UNINSTALL; -} - -bool ParamChecker::ValidatePkgID() { - if (pkgid_.size() == 0) { - LOG(ERROR) << "pkgid is empty"; - return false; - } - - return true; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/remove_request_handler.cc b/src/rsc-copy/src/remove_request_handler.cc deleted file mode 100644 index af7581b..0000000 --- a/src/rsc-copy/src/remove_request_handler.cc +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/remove_request_handler.hh" - -#include -#include - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/error_type.hh" -#include "include/file_util.hh" -#include "include/logging.hh" -#include "include/rsc_path_info.hh" - -namespace bf = boost::filesystem; - -namespace { - -constexpr char kRemoveReqHandlerType[] = "remove"; - -} // namespace - -namespace rsc_handler { - -RemoveRequestHandler::RemoveRequestHandler( - std::string pkgid, std::string root_path, - std::list path_list) : - AbstractRequestHandler(pkgid, root_path, path_list) {} - -ErrorType RemoveRequestHandler::Execute() { - bf::path root_path(GetRootPath()); - bf::path dst_root_path = root_path / "shared_res" / GetPkgID(); - - if (!bf::exists(dst_root_path)) { - LOG(ERROR) << "root path not exists"; - return ErrorType::ERROR_RES_NOT_FOUND; - } - - for (auto& path_info : GetPathList()) { - bf::path dst_path = dst_root_path / path_info.GetSrcPath(); - if (!bf::exists(dst_path)) { - LOG(ERROR) << "Path not exists: " << dst_path; - continue; - } - - if (!RemoveAll(dst_path)) - return ErrorType::ERROR_SYSTEM_ERROR; - } - - return ErrorType::ERROR_NONE; -} - -const std::string RemoveRequestHandler::GetRequestHandlerType() const { - return kRemoveReqHandlerType; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/request_handler_invoker.cc b/src/rsc-copy/src/request_handler_invoker.cc deleted file mode 100644 index 2b95f57..0000000 --- a/src/rsc-copy/src/request_handler_invoker.cc +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/request_handler_invoker.hh" - -#include - -#include - -#include "include/abstract_request_handler.hh" -#include "include/condition_validator.hh" -#include "include/copy_request_handler.hh" -#include "include/event_signal_sender.hh" -#include "include/logging.hh" -#include "include/param_checker.hh" -#include "include/remove_request_handler.hh" -#include "include/request_type.hh" -#include "include/uninstall_request_handler.hh" - -namespace { - -std::string GetRootPathForUid(uid_t uid) { - tzplatform_set_user(uid); - const char* rootpath = tzplatform_getenv(TZ_USER_HOME); - tzplatform_reset_user(); - return rootpath; -} - -} // namespace - -namespace rsc_handler { - -RequestHandlerInvoker::RequestHandlerInvoker( - ParamChecker option, EventSignalSender signal) : - option_(option), signal_(signal) { - SetReqHandler(); -} - -bool RequestHandlerInvoker::Validate() { - if (handler_ == nullptr) { - LOG(ERROR) << "Failed to initialize handler"; - return false; - } - - ConditionValidator validator(option_.GetPkgID(), option_.GetUID()); - if (validator.ValidateCondition( - option_.GetRequestType(), option_.GetPathList()) - != ErrorType::ERROR_NONE) { - LOG(ERROR) << "Validation failed"; - return false; - } - - return true; -} - -bool RequestHandlerInvoker::Execute() { - if (handler_ == nullptr) - return false; - - if (handler_->Execute() != ErrorType::ERROR_NONE) - return false; - - return true; -} - -const std::string RequestHandlerInvoker::GetHandlerType() const { - if (handler_ == nullptr) { - LOG(ERROR) << "handler has not initialized"; - return {}; - } - - return handler_->GetRequestHandlerType(); -} - -void RequestHandlerInvoker::SetReqHandler() { - switch (option_.GetRequestType()) { - case ReqType::REQ_TYPE_NEW: - handler_.reset( - new CopyRequestHandler( - option_.GetPkgID(), - GetRootPathForUid(option_.GetUID()), - option_.GetPathList())); - break; - case ReqType::REQ_TYPE_REMOVE: - - handler_.reset( - new RemoveRequestHandler( - option_.GetPkgID(), - GetRootPathForUid(option_.GetUID()), - option_.GetPathList())); - break; - case ReqType::REQ_TYPE_UNINSTALL: - handler_.reset( - new UninstallRequestHandler( - option_.GetPkgID(), - GetRootPathForUid(option_.GetUID()), - option_.GetPathList())); - break; - default: - LOG(ERROR) << "Invalid request type"; - break; - } -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/rsc_copy_main.cc b/src/rsc-copy/src/rsc_copy_main.cc deleted file mode 100644 index 445baf3..0000000 --- a/src/rsc-copy/src/rsc_copy_main.cc +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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. - */ - -#include - -#include "include/rsc_handler.hh" -#include "include/logging.hh" - -int main(int argc, char *argv[]) { - try { - rsc_handler::RscHandler handler; - if (!handler.Init(argc, argv)) { - LOG(ERROR) << "Failed to initliaze handler"; - return -1; - } - - if (!handler.Run()) { - LOG(ERROR) << "Failed to handle request"; - return -1; - } - } catch (...) { - LOG(ERROR) << "Exception occured"; - return -1; - } - - return 0; -} diff --git a/src/rsc-copy/src/rsc_handler.cc b/src/rsc-copy/src/rsc_handler.cc deleted file mode 100644 index b954e50..0000000 --- a/src/rsc-copy/src/rsc_handler.cc +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/rsc_handler.hh" - -#include - -#include "include/event_signal_sender.hh" -#include "include/logging.hh" -#include "include/param_checker.hh" -#include "include/request_handler_invoker.hh" - -namespace rsc_handler { - -bool RscHandler::Init(int argc, char* argv[]) { - rsc_handler::ParamChecker option(argc, argv); - if (!option.Validate()) { - LOG(ERROR) << "Invalid argument has given"; - return false; - } - - rsc_handler::EventSignalSender signal; - signal.SetPkgID(option.GetPkgID()); - signal.SetReqType(option.GetRequestType()); - - handler_.reset(new rsc_handler::RequestHandlerInvoker(option, signal)); - if (!handler_->Validate()) { - LOG(ERROR) << "Failed to initialize request handler"; - return false; - } - - return true; -} - -bool RscHandler::Run() { - return handler_->Execute(); -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/rsc_path_info.cc b/src/rsc-copy/src/rsc_path_info.cc deleted file mode 100644 index 8e4e37f..0000000 --- a/src/rsc-copy/src/rsc_path_info.cc +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/rsc_path_info.hh" - -#include -#include - -namespace rsc_handler { - -RscPathInfo::RscPathInfo(std::string src, std::string dst) : - src_(src), dst_(dst) {} - -const std::string& RscPathInfo::GetSrcPath() const { - return src_; -} - -const std::string& RscPathInfo::GetDstPath() const { - return dst_; -} - -} // namespace rsc_handler diff --git a/src/rsc-copy/src/uninstall_request_handler.cc b/src/rsc-copy/src/uninstall_request_handler.cc deleted file mode 100644 index abb66a9..0000000 --- a/src/rsc-copy/src/uninstall_request_handler.cc +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 "include/uninstall_request_handler.hh" - -#include -#include - -#include "include/abstract_request_handler.hh" -#include "include/error_type.hh" -#include "include/file_util.hh" -#include "include/logging.hh" -#include "include/rsc_path_info.hh" - -namespace bf = boost::filesystem; - -namespace { - -constexpr char kUninstallReqHandlerType[] = "delete"; - -} // namespace - -namespace rsc_handler { - -UninstallRequestHandler::UninstallRequestHandler( - std::string pkgid, std::string root_path, - std::list path_list) : - AbstractRequestHandler(pkgid, root_path, path_list) {} - -ErrorType UninstallRequestHandler::Execute() { - if (GetPkgID().length() == 0) { - LOG(ERROR) << "Invalid argument"; - return ErrorType::ERROR_INVALID_PARAMETER; - } - - bf::path root_path(GetRootPath()); - root_path = root_path / "shared_res" / GetPkgID(); - - if (!bf::exists(root_path)) { - LOG(WARNING) << "path not exists : " << root_path; - return ErrorType::ERROR_NONE; - } - - if (!RemoveAll(root_path)) - return ErrorType::ERROR_SYSTEM_ERROR; - - return ErrorType::ERROR_NONE; -} - -const std::string UninstallRequestHandler::GetRequestHandlerType() const { - return kUninstallReqHandlerType; -} - -} // namespace rsc_handler diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt index 37bfcb4..7591000 100644 --- a/tests/unit_tests/CMakeLists.txt +++ b/tests/unit_tests/CMakeLists.txt @@ -25,7 +25,7 @@ SET(CMAKE_CXX_FLAGS_RELEASE "-O2") ADD_DEFINITIONS("-DDB_PATH=\"${DB_PATH}\"") INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src/pkg_upgrade/include) -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src/rsc-copy/) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src/res-copy/) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../) #pkg_upgrade @@ -33,20 +33,20 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/pkg_upgrade/src PKG_UPGRADE_SRC AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/pkg_upgrade/src PKG_UPGRADE_LIB_SOURCES) LIST(REMOVE_ITEM PKG_UPGRADE_LIB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../../src/pkg_upgrade/src/main.cc) -#rsc-copy -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/rsc-copy/src RSC_COPY_SRCS) -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/rsc-copy/src RSC_COPY_LIB_SOURCES) -LIST(REMOVE_ITEM RSC_COPY_LIB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../../src/rsc-copy/src/rsc_copy_main.cc) -LIST(REMOVE_ITEM RSC_COPY_LIB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../../src/rsc-copy/src/logging.cc) +#res-copy +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/res-copy/src RES_COPY_SRCS) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/res-copy/src RES_COPY_LIB_SOURCES) +LIST(REMOVE_ITEM RES_COPY_LIB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../../src/res-copy/src/res_copy_main.cc) +LIST(REMOVE_ITEM RES_COPY_LIB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../../src/res-copy/src/logging.cc) AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock MOCK_SOURCES) ADD_EXECUTABLE(${PROJECT_NAME} ${PKG_UPGRADE_SRCS} - ${RSC_COPY_SRCS} + ${RES_COPY_SRCS} ${MOCK_SOURCES} ${PKG_UPGRADE_LIB_SOURCES} - ${RSC_COPY_LIB_SOURCES} + ${RES_COPY_LIB_SOURCES} test_main.cc ) diff --git a/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_dir2/resource_file2.txt b/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_dir2/resource_file2.txt new file mode 100644 index 0000000..409d6cf --- /dev/null +++ b/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_dir2/resource_file2.txt @@ -0,0 +1 @@ +this is second resource file diff --git a/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_file3.txt b/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_file3.txt new file mode 100644 index 0000000..241ce06 --- /dev/null +++ b/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_file3.txt @@ -0,0 +1 @@ +this is 3rd resource file diff --git a/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_file.txt b/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_file.txt new file mode 100644 index 0000000..93ec8fc --- /dev/null +++ b/tests/unit_tests/res-copy/data/apps_rw/test_pkg/data/resource_file.txt @@ -0,0 +1 @@ +this is resource file to being copied diff --git a/tests/unit_tests/res-copy/src/test_condition_validator.cc b/tests/unit_tests/res-copy/src/test_condition_validator.cc new file mode 100644 index 0000000..ffa46c5 --- /dev/null +++ b/tests/unit_tests/res-copy/src/test_condition_validator.cc @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 +#include +#include + +#include + +#include "mock/os_mock.h" +#include "mock/pkgmgr_info_mock.h" +#include "mock/test_fixture.h" + +#include "include/condition_validator.hh" +#include "include/param_checker.hh" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Invoke; +using ::testing::Return; +using ::testing::SetArgPointee; +using ::testing::InvokeArgument; +using ::testing::SaveArg; + +using res_handler::ConditionValidator; +using res_handler::ParamChecker; + +class Mocks : public ::testing::NiceMock, + public ::testing::NiceMock {}; + +class ConditionValidatorTest : public TestFixture { + public: + ConditionValidatorTest() : TestFixture(std::make_unique()) {} + virtual ~ConditionValidatorTest() {} + + virtual void SetUp() { + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) + .WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_destroy_pkginfo(_)) + .WillRepeatedly(Return(0)) ; + } + virtual void TearDown() {} +}; + +TEST_F(ConditionValidatorTest, PkgNotExist) { + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) + .WillRepeatedly(Return(-1)); + + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--copy", + "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); + res_handler::ErrorType ret = validator.ValidateCondition( + checker.GetRequestType(), checker.GetPathList()); + + EXPECT_EQ(ret, res_handler::ErrorType::ERROR_PKG_NOT_FOUND); +} + +TEST_F(ConditionValidatorTest, CopyPkgNotExist) { + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) + .WillRepeatedly(Return(-1)); + + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--copy", + "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); + res_handler::ErrorType ret = validator.ValidateCondition( + checker.GetRequestType(), checker.GetPathList()); + + EXPECT_EQ(ret, res_handler::ErrorType::ERROR_PKG_NOT_FOUND); +} + +TEST_F(ConditionValidatorTest, CopySrcNotExist) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--copy", + "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); + res_handler::ErrorType ret = validator.ValidateCondition( + checker.GetRequestType(), checker.GetPathList()); + + EXPECT_EQ(ret, res_handler::ErrorType::ERROR_RES_NOT_FOUND); +} + +TEST_F(ConditionValidatorTest, RemovePkgNotExist) { + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) + .WillRepeatedly(Return(-1)); + + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--remove", + "org.test.targetpkgid", "-p", "", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); + res_handler::ErrorType ret = validator.ValidateCondition( + checker.GetRequestType(), checker.GetPathList()); + + EXPECT_EQ(ret, res_handler::ErrorType::ERROR_PKG_NOT_FOUND); +} + +TEST_F(ConditionValidatorTest, RemoveSrcNotExist) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--remove", + "org.test.targetpkgid", "-p", "", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); + res_handler::ErrorType ret = validator.ValidateCondition( + checker.GetRequestType(), checker.GetPathList()); + + EXPECT_EQ(ret, res_handler::ErrorType::ERROR_RES_NOT_FOUND); +} + +TEST_F(ConditionValidatorTest, DeletePkgNotExist) { + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) + .WillRepeatedly(Return(-1)); + + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--delete", + "org.test.targetpkgid", nullptr}; + ParamChecker checker(5, (char**)argv); + ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); + res_handler::ErrorType ret = validator.ValidateCondition( + checker.GetRequestType(), checker.GetPathList()); + + EXPECT_EQ(ret, res_handler::ErrorType::ERROR_PKG_NOT_FOUND); +} + diff --git a/tests/unit_tests/res-copy/src/test_param_checker.cc b/tests/unit_tests/res-copy/src/test_param_checker.cc new file mode 100644 index 0000000..69163e9 --- /dev/null +++ b/tests/unit_tests/res-copy/src/test_param_checker.cc @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 +#include +#include + +#include + +#include "mock/os_mock.h" +#include "mock/pkgmgr_info_mock.h" +#include "mock/test_fixture.h" +#include "include/param_checker.hh" +#include "include/request_type.hh" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Invoke; +using ::testing::Return; +using ::testing::SetArgPointee; +using ::testing::InvokeArgument; +using ::testing::SaveArg; + +using res_handler::ParamChecker; + +class Mocks : public ::testing::NiceMock, + public ::testing::NiceMock {}; + +class ParamCheckerTest : public TestFixture { + public: + ParamCheckerTest() : TestFixture(std::make_unique()) {} + virtual ~ParamCheckerTest() {} + + virtual void SetUp() { + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) + .WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_destroy_pkginfo(_)) + .WillRepeatedly(Return(0)) ; + } + virtual void TearDown() {} +}; + +TEST_F(ParamCheckerTest, InvalidUIDTest) { + const char *argv[] = { "/bin/res-copy", "--uid", "0", "--copy", + "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + + EXPECT_EQ(checker.Validate(), false); +} + +TEST_F(ParamCheckerTest, PkgIDNotGiven) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", + "-p", "srcpath", "dstpath", "--copy", "", nullptr}; + ParamChecker checker(8, (char**)argv); + + EXPECT_EQ(checker.Validate(), false); +} + +TEST_F(ParamCheckerTest, CopyRes) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "-p", "srcpath", "dstpath", + "--copy", "org.test.targetpkgid", nullptr}; + + ParamChecker checker(8, (char**)argv); + + EXPECT_EQ(checker.Validate(), true); + EXPECT_EQ(checker.GetRequestType(), res_handler::ReqType::REQ_TYPE_NEW); + EXPECT_EQ(checker.GetPkgID(), "org.test.targetpkgid"); + EXPECT_EQ(checker.GetPathList().size(), 1); + EXPECT_EQ(checker.GetUID(), 5001); +} + +TEST_F(ParamCheckerTest, RemoveRes) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--remove", + "org.test.targetpkgid", "-p", "dstpath", nullptr}; + + ParamChecker checker(7, (char**)argv); + + EXPECT_EQ(checker.Validate(), true); + EXPECT_EQ(checker.GetRequestType(), res_handler::ReqType::REQ_TYPE_REMOVE); + EXPECT_EQ(checker.GetPkgID(), "org.test.targetpkgid"); + EXPECT_EQ(checker.GetPathList().size(), 1); + EXPECT_EQ(checker.GetUID(), 5001); +} + +TEST_F(ParamCheckerTest, DeleteRes) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--delete", + "org.test.targetpkgid", nullptr}; + + ParamChecker checker(5, (char**)argv); + + EXPECT_EQ(checker.Validate(), true); + EXPECT_EQ(checker.GetRequestType(), res_handler::ReqType::REQ_TYPE_UNINSTALL); + EXPECT_EQ(checker.GetPkgID(), "org.test.targetpkgid"); + EXPECT_EQ(checker.GetPathList().size(), 0); + EXPECT_EQ(checker.GetUID(), 5001); +} + +TEST_F(ParamCheckerTest, EmptyPkgID) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--copy", + "", "-p", "srcpath", "dstpath", nullptr}; + ParamChecker checker(8,(char**)argv); + + EXPECT_EQ(checker.Validate(), false); +} + +TEST_F(ParamCheckerTest, UnknownReqType) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "-p", + "srcpath", "dstpath", nullptr}; + ParamChecker checker(6, (char**)argv); + + EXPECT_EQ(checker.Validate(), false); +} + +TEST_F(ParamCheckerTest, PathNotGiven) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", + "-c", "org.tizen.pathnotgiven", nullptr}; + ParamChecker checker(5, (char**)argv); + + EXPECT_EQ(checker.Validate(), false); +} diff --git a/tests/unit_tests/res-copy/src/test_request_handler.cc b/tests/unit_tests/res-copy/src/test_request_handler.cc new file mode 100644 index 0000000..3586c1b --- /dev/null +++ b/tests/unit_tests/res-copy/src/test_request_handler.cc @@ -0,0 +1,435 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include "mock/os_mock.h" +#include "mock/pkgmgr_info_mock.h" +#include "mock/test_fixture.h" + +#include "include/abstract_request_handler.hh" +#include "include/copy_request_handler.hh" +#include "include/error_type.hh" +#include "include/param_checker.hh" +#include "include/remove_request_handler.hh" +#include "include/request_type.hh" +#include "include/uninstall_request_handler.hh" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Invoke; +using ::testing::Return; +using ::testing::SetArgPointee; +using ::testing::InvokeArgument; +using ::testing::SaveArg; + +using res_handler::CopyRequestHandler; +using res_handler::RemoveRequestHandler; +using res_handler::ResPathInfo; +using res_handler::UninstallRequestHandler; + +namespace bf = boost::filesystem; +namespace bs = boost::system; + +class Mocks : public ::testing::NiceMock, + public ::testing::NiceMock {}; + +class CopyRequestHandlerTest : public TestFixture { + public: + CopyRequestHandlerTest() : TestFixture(std::make_unique()) {} + virtual ~CopyRequestHandlerTest() {} + + virtual void SetUp() { + bf::path rootpath(root_path); + bf::create_directories( + rootpath / "shared_res/test_pkg/dest_dir"); + } + virtual void TearDown() { + bf::remove_all("./tests/unit_tests/res-copy/data/shared_res/test_pkg"); + } + + std::string root_path = "./tests/unit_tests/res-copy/data"; +}; + +class RemoveRequestHandlerTest : public TestFixture { + public: + RemoveRequestHandlerTest() : TestFixture(std::make_unique()) {} + virtual ~RemoveRequestHandlerTest() {} + + virtual void SetUp() { + bf::path rootpath(root_path); + bf::create_directories( + rootpath / "shared_res/test_pkg/new_dir/new_dir2"); + + bf::copy_file(rootpath / "apps_rw/test_pkg/data/resource_file.txt", + rootpath / "shared_res/test_pkg/resource_file.txt"); + + bf::copy_file(rootpath / "apps_rw/test_pkg/data/resource_file.txt", + rootpath / "shared_res/test_pkg/new_dir/resource_file.txt"); + + bf::copy_file(rootpath / "apps_rw/test_pkg/data/resource_file.txt", + rootpath / "shared_res/test_pkg/new_dir/new_dir2/resource_file.txt"); + } + virtual void TearDown() { + bf::remove_all("./tests/unit_tests/res-copy/data/shared_res/test_pkg"); + } + + std::string root_path = "./tests/unit_tests/res-copy/data"; +}; + +class UninstallRequestHandlerTest : public TestFixture { + public: + UninstallRequestHandlerTest() : TestFixture(std::make_unique()) {} + virtual ~UninstallRequestHandlerTest() {} + + virtual void SetUp() { + bf::path rootpath(root_path); + bf::create_directories( + rootpath / "shared_res/test_pkg"); + } + virtual void TearDown() { + bf::remove_all("./tests/unit_tests/res-copy/data/shared_res/test_pkg"); + } + + std::string root_path = "./tests/unit_tests/res-copy/data"; +}; + +TEST_F(CopyRequestHandlerTest, CopyFileAtRootToRoot) { + std::list path_list; + path_list.emplace_back("data/resource_file.txt", ""); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyFileAtRootToRoot_ChangeFileName) { + std::list path_list; + path_list.emplace_back("data/resource_file.txt", "another_name.txt"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "another_name.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyFileAtRootToDirectory) { + std::list path_list; + path_list.emplace_back("data/resource_file.txt", "dest_dir"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "dest_dir"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyFileAtRootToDirectory_ChangeFileName) { + std::list path_list; + path_list.emplace_back("data/resource_file.txt", "dest_dir/newname.txt"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "dest_dir"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "newname.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToRoot) { + std::list path_list; + path_list.emplace_back("data/resource_dir1/resource_file3.txt", ""); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file3.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToRoot_ChangeFileName) { + std::list path_list; + path_list.emplace_back( + "data/resource_dir1/resource_file3.txt", "newname.txt"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "newname.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToDirectory) { + std::list path_list; + path_list.emplace_back("data/resource_dir1/resource_file3.txt", "dest_dir"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "dest_dir"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file3.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToRoot_ChangeFileName) { + std::list path_list; + path_list.emplace_back( + "data/resource_dir1/resource_file3.txt", "dest_dir/newname.txt"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "dest_dir"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "newname.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToRoot) { + std::list path_list; + path_list.emplace_back("data/resource_dir1", ""); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file3.txt"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path = check_path.parent_path(); + check_path /= "resource_dir2"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file2.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToDirectory) { + std::list path_list; + path_list.emplace_back("data/resource_dir1", "dest_dir"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "dest_dir"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file3.txt"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path = check_path.parent_path(); + check_path /= "resource_dir2"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file2.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToDirectory2) { + std::list path_list; + path_list.emplace_back("data/resource_dir1", "resource_dir1"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_dir1"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file3.txt"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path = check_path.parent_path(); + check_path /= "resource_dir2"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file2.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyDirectoryAtDirectoryToRoot) { + std::list path_list; + path_list.emplace_back("data/resource_dir1/resource_dir2", ""); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file2.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, CopyDirectoryAtDirectoryToDirectory) { + std::list path_list; + path_list.emplace_back("data/resource_dir1/resource_dir2", "dest_dir"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg"); + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "dest_dir"; + EXPECT_TRUE(bf::exists(check_path)); + + check_path /= "resource_file2.txt"; + EXPECT_TRUE(bf::exists(check_path)); +} + +TEST_F(CopyRequestHandlerTest, ResNotexists) { + std::list path_list; + path_list.emplace_back("data/not_existed_res", "new_dir"); + CopyRequestHandler handler("test_pkg", root_path, path_list); + + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_RES_NOT_FOUND); +} + +TEST_F(CopyRequestHandlerTest, ReplaceRes) { + std::list path_list; + path_list.emplace_back("data/resource_file.txt", "new_dir"); + + CopyRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + CopyRequestHandler replace_handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); +} + +TEST_F(RemoveRequestHandlerTest, RemoveFileAtRoot) { + std::list path_list; + path_list.emplace_back("resource_file.txt", ""); + + RemoveRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg/resource_file.txt"); + EXPECT_FALSE(bf::exists(check_path)); +} + +TEST_F(RemoveRequestHandlerTest, RemoveFileAtDirectory) { + std::list path_list; + path_list.emplace_back("new_dir/resource_file.txt", ""); + + RemoveRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path( + root_path + "/shared_res/test_pkg/new_dir/resource_file.txt"); + EXPECT_FALSE(bf::exists(check_path)); +} + +TEST_F(RemoveRequestHandlerTest, RemoveDirectoryAtRoot) { + std::list path_list; + path_list.emplace_back("new_dir", ""); + + RemoveRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg/new_dir"); + EXPECT_FALSE(bf::exists(check_path)); +} + +TEST_F(RemoveRequestHandlerTest, RemoveDirectoryAtDirectory) { + std::list path_list; + path_list.emplace_back("new_dir/new_dir2", ""); + + RemoveRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg/new_dir/new_dir2"); + EXPECT_FALSE(bf::exists(check_path)); +} + +TEST_F(UninstallRequestHandlerTest, RemoveRootPath) { + std::list path_list; + + UninstallRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); + + bf::path check_path(root_path + "/shared_res/test_pkg/"); + EXPECT_FALSE(bf::exists(check_path)); +} + +TEST_F(UninstallRequestHandlerTest, RootNotExists) { + std::list path_list; + bf::path check_path(root_path + "/shared_res/test_pkg/"); + bf::remove_all(check_path); + + UninstallRequestHandler handler("test_pkg", root_path, path_list); + EXPECT_EQ(handler.Execute(), res_handler::ErrorType::ERROR_NONE); +} + +TEST_F(UninstallRequestHandlerTest, EmptyPkgID) { + std::list path_list; + + UninstallRequestHandler handler("", root_path, path_list); + EXPECT_EQ(handler.Execute(), + res_handler::ErrorType::ERROR_INVALID_PARAMETER); +} diff --git a/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc b/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc new file mode 100644 index 0000000..ff8bf6a --- /dev/null +++ b/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * 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 +#include +#include + +#include + +#include "mock/os_mock.h" +#include "mock/pkgmgr_info_mock.h" +#include "mock/test_fixture.h" +#include "include/event_signal_sender.hh" +#include "include/param_checker.hh" +#include "include/request_handler_invoker.hh" +#include "include/request_type.hh" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Invoke; +using ::testing::Return; +using ::testing::SetArgPointee; +using ::testing::InvokeArgument; +using ::testing::SaveArg; + +using res_handler::ParamChecker; +using res_handler::RequestHandlerInvoker; + +class Mocks : public ::testing::NiceMock, + public ::testing::NiceMock {}; + +class RequestHandlerInvokerTest : public TestFixture { + public: + RequestHandlerInvokerTest() : TestFixture(std::make_unique()) { + 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_; +}; + +TEST_F(RequestHandlerInvokerTest, CopyType) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--copy", + "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + + RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); + EXPECT_EQ(request_handler_invoker.GetHandlerType(), "copy"); + +} + +TEST_F(RequestHandlerInvokerTest, RemoveType) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--remove", + "org.test.targetpkgid", "-p", "", "dstpath", nullptr}; + ParamChecker checker(8, (char**)argv); + + RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); + EXPECT_EQ(request_handler_invoker.GetHandlerType(), "remove"); +} + +TEST_F(RequestHandlerInvokerTest, UninstallType) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", "--delete", + "org.test.targetpkgid", nullptr}; + ParamChecker checker(5, (char**)argv); + + RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); + EXPECT_EQ(request_handler_invoker.GetHandlerType(), "delete"); +} + +TEST_F(RequestHandlerInvokerTest, InvalidType) { + const char *argv[] = { "/bin/res-copy", "--uid", "5001", nullptr}; + ParamChecker checker(3, (char**)argv); + + RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); + EXPECT_EQ(request_handler_invoker.GetHandlerType(), ""); + EXPECT_EQ(request_handler_invoker.Execute(), false); +} diff --git a/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_dir2/resource_file2.txt b/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_dir2/resource_file2.txt deleted file mode 100644 index 409d6cf..0000000 --- a/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_dir2/resource_file2.txt +++ /dev/null @@ -1 +0,0 @@ -this is second resource file diff --git a/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_file3.txt b/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_file3.txt deleted file mode 100644 index 241ce06..0000000 --- a/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_dir1/resource_file3.txt +++ /dev/null @@ -1 +0,0 @@ -this is 3rd resource file diff --git a/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_file.txt b/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_file.txt deleted file mode 100644 index 93ec8fc..0000000 --- a/tests/unit_tests/rsc-copy/data/apps_rw/test_pkg/data/resource_file.txt +++ /dev/null @@ -1 +0,0 @@ -this is resource file to being copied diff --git a/tests/unit_tests/rsc-copy/src/test_condition_validator.cc b/tests/unit_tests/rsc-copy/src/test_condition_validator.cc deleted file mode 100644 index fd13222..0000000 --- a/tests/unit_tests/rsc-copy/src/test_condition_validator.cc +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 -#include -#include - -#include - -#include "mock/os_mock.h" -#include "mock/pkgmgr_info_mock.h" -#include "mock/test_fixture.h" - -#include "include/condition_validator.hh" -#include "include/param_checker.hh" - -using ::testing::_; -using ::testing::DoAll; -using ::testing::Invoke; -using ::testing::Return; -using ::testing::SetArgPointee; -using ::testing::InvokeArgument; -using ::testing::SaveArg; - -using rsc_handler::ConditionValidator; -using rsc_handler::ParamChecker; - -class Mocks : public ::testing::NiceMock, - public ::testing::NiceMock {}; - -class ConditionValidatorTest : public TestFixture { - public: - ConditionValidatorTest() : TestFixture(std::make_unique()) {} - virtual ~ConditionValidatorTest() {} - - virtual void SetUp() { - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) - .WillRepeatedly(Return(0)); - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_destroy_pkginfo(_)) - .WillRepeatedly(Return(0)) ; - } - virtual void TearDown() {} -}; - -TEST_F(ConditionValidatorTest, PkgNotExist) { - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) - .WillRepeatedly(Return(-1)); - - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--copy", - "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); - rsc_handler::ErrorType ret = validator.ValidateCondition( - checker.GetRequestType(), checker.GetPathList()); - - EXPECT_EQ(ret, rsc_handler::ErrorType::ERROR_PKG_NOT_FOUND); -} - -TEST_F(ConditionValidatorTest, CopyPkgNotExist) { - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) - .WillRepeatedly(Return(-1)); - - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--copy", - "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); - rsc_handler::ErrorType ret = validator.ValidateCondition( - checker.GetRequestType(), checker.GetPathList()); - - EXPECT_EQ(ret, rsc_handler::ErrorType::ERROR_PKG_NOT_FOUND); -} - -TEST_F(ConditionValidatorTest, CopySrcNotExist) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--copy", - "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); - rsc_handler::ErrorType ret = validator.ValidateCondition( - checker.GetRequestType(), checker.GetPathList()); - - EXPECT_EQ(ret, rsc_handler::ErrorType::ERROR_RES_NOT_FOUND); -} - -TEST_F(ConditionValidatorTest, RemovePkgNotExist) { - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) - .WillRepeatedly(Return(-1)); - - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--remove", - "org.test.targetpkgid", "-p", "", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); - rsc_handler::ErrorType ret = validator.ValidateCondition( - checker.GetRequestType(), checker.GetPathList()); - - EXPECT_EQ(ret, rsc_handler::ErrorType::ERROR_PKG_NOT_FOUND); -} - -TEST_F(ConditionValidatorTest, RemoveSrcNotExist) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--remove", - "org.test.targetpkgid", "-p", "", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); - rsc_handler::ErrorType ret = validator.ValidateCondition( - checker.GetRequestType(), checker.GetPathList()); - - EXPECT_EQ(ret, rsc_handler::ErrorType::ERROR_RES_NOT_FOUND); -} - -TEST_F(ConditionValidatorTest, DeletePkgNotExist) { - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) - .WillRepeatedly(Return(-1)); - - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--delete", - "org.test.targetpkgid", nullptr}; - ParamChecker checker(5, (char**)argv); - ConditionValidator validator(checker.GetPkgID(), checker.GetUID()); - rsc_handler::ErrorType ret = validator.ValidateCondition( - checker.GetRequestType(), checker.GetPathList()); - - EXPECT_EQ(ret, rsc_handler::ErrorType::ERROR_PKG_NOT_FOUND); -} - diff --git a/tests/unit_tests/rsc-copy/src/test_param_checker.cc b/tests/unit_tests/rsc-copy/src/test_param_checker.cc deleted file mode 100644 index e1e1c93..0000000 --- a/tests/unit_tests/rsc-copy/src/test_param_checker.cc +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 -#include -#include - -#include - -#include "mock/os_mock.h" -#include "mock/pkgmgr_info_mock.h" -#include "mock/test_fixture.h" -#include "include/param_checker.hh" -#include "include/request_type.hh" - -using ::testing::_; -using ::testing::DoAll; -using ::testing::Invoke; -using ::testing::Return; -using ::testing::SetArgPointee; -using ::testing::InvokeArgument; -using ::testing::SaveArg; - -using rsc_handler::ParamChecker; - -class Mocks : public ::testing::NiceMock, - public ::testing::NiceMock {}; - -class ParamCheckerTest : public TestFixture { - public: - ParamCheckerTest() : TestFixture(std::make_unique()) {} - virtual ~ParamCheckerTest() {} - - virtual void SetUp() { - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_get_usr_pkginfo(_, _, _)) - .WillRepeatedly(Return(0)); - EXPECT_CALL(GetMock(), pkgmgrinfo_pkginfo_destroy_pkginfo(_)) - .WillRepeatedly(Return(0)) ; - } - virtual void TearDown() {} -}; - -TEST_F(ParamCheckerTest, InvalidUIDTest) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "0", "--copy", - "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - - EXPECT_EQ(checker.Validate(), false); -} - -TEST_F(ParamCheckerTest, PkgIDNotGiven) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", - "-p", "srcpath", "dstpath", "--copy", "", nullptr}; - ParamChecker checker(8, (char**)argv); - - EXPECT_EQ(checker.Validate(), false); -} - -TEST_F(ParamCheckerTest, CopyRsc) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "-p", "srcpath", "dstpath", - "--copy", "org.test.targetpkgid", nullptr}; - - ParamChecker checker(8, (char**)argv); - - EXPECT_EQ(checker.Validate(), true); - EXPECT_EQ(checker.GetRequestType(), rsc_handler::ReqType::REQ_TYPE_NEW); - EXPECT_EQ(checker.GetPkgID(), "org.test.targetpkgid"); - EXPECT_EQ(checker.GetPathList().size(), 1); - EXPECT_EQ(checker.GetUID(), 5001); -} - -TEST_F(ParamCheckerTest, RemoveRsc) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--remove", - "org.test.targetpkgid", "-p", "dstpath", nullptr}; - - ParamChecker checker(7, (char**)argv); - - EXPECT_EQ(checker.Validate(), true); - EXPECT_EQ(checker.GetRequestType(), rsc_handler::ReqType::REQ_TYPE_REMOVE); - EXPECT_EQ(checker.GetPkgID(), "org.test.targetpkgid"); - EXPECT_EQ(checker.GetPathList().size(), 1); - EXPECT_EQ(checker.GetUID(), 5001); -} - -TEST_F(ParamCheckerTest, DeleteRsc) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--delete", - "org.test.targetpkgid", nullptr}; - - ParamChecker checker(5, (char**)argv); - - EXPECT_EQ(checker.Validate(), true); - EXPECT_EQ(checker.GetRequestType(), rsc_handler::ReqType::REQ_TYPE_UNINSTALL); - EXPECT_EQ(checker.GetPkgID(), "org.test.targetpkgid"); - EXPECT_EQ(checker.GetPathList().size(), 0); - EXPECT_EQ(checker.GetUID(), 5001); -} - -TEST_F(ParamCheckerTest, EmptyPkgID) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--copy", - "", "-p", "srcpath", "dstpath", nullptr}; - ParamChecker checker(8,(char**)argv); - - EXPECT_EQ(checker.Validate(), false); -} - -TEST_F(ParamCheckerTest, UnknownReqType) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "-p", - "srcpath", "dstpath", nullptr}; - ParamChecker checker(6, (char**)argv); - - EXPECT_EQ(checker.Validate(), false); -} - -TEST_F(ParamCheckerTest, PathNotGiven) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", - "-c", "org.tizen.pathnotgiven", nullptr}; - ParamChecker checker(5, (char**)argv); - - EXPECT_EQ(checker.Validate(), false); -} diff --git a/tests/unit_tests/rsc-copy/src/test_request_handler.cc b/tests/unit_tests/rsc-copy/src/test_request_handler.cc deleted file mode 100644 index 8373591..0000000 --- a/tests/unit_tests/rsc-copy/src/test_request_handler.cc +++ /dev/null @@ -1,435 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 -#include -#include - -#include -#include -#include - -#include -#include -#include - -#include "mock/os_mock.h" -#include "mock/pkgmgr_info_mock.h" -#include "mock/test_fixture.h" - -#include "include/abstract_request_handler.hh" -#include "include/copy_request_handler.hh" -#include "include/error_type.hh" -#include "include/param_checker.hh" -#include "include/remove_request_handler.hh" -#include "include/request_type.hh" -#include "include/uninstall_request_handler.hh" - -using ::testing::_; -using ::testing::DoAll; -using ::testing::Invoke; -using ::testing::Return; -using ::testing::SetArgPointee; -using ::testing::InvokeArgument; -using ::testing::SaveArg; - -using rsc_handler::CopyRequestHandler; -using rsc_handler::RemoveRequestHandler; -using rsc_handler::RscPathInfo; -using rsc_handler::UninstallRequestHandler; - -namespace bf = boost::filesystem; -namespace bs = boost::system; - -class Mocks : public ::testing::NiceMock, - public ::testing::NiceMock {}; - -class CopyRequestHandlerTest : public TestFixture { - public: - CopyRequestHandlerTest() : TestFixture(std::make_unique()) {} - virtual ~CopyRequestHandlerTest() {} - - virtual void SetUp() { - bf::path rootpath(root_path); - bf::create_directories( - rootpath / "shared_res/test_pkg/dest_dir"); - } - virtual void TearDown() { - bf::remove_all("./tests/unit_tests/rsc-copy/data/shared_res/test_pkg"); - } - - std::string root_path = "./tests/unit_tests/rsc-copy/data"; -}; - -class RemoveRequestHandlerTest : public TestFixture { - public: - RemoveRequestHandlerTest() : TestFixture(std::make_unique()) {} - virtual ~RemoveRequestHandlerTest() {} - - virtual void SetUp() { - bf::path rootpath(root_path); - bf::create_directories( - rootpath / "shared_res/test_pkg/new_dir/new_dir2"); - - bf::copy_file(rootpath / "apps_rw/test_pkg/data/resource_file.txt", - rootpath / "shared_res/test_pkg/resource_file.txt"); - - bf::copy_file(rootpath / "apps_rw/test_pkg/data/resource_file.txt", - rootpath / "shared_res/test_pkg/new_dir/resource_file.txt"); - - bf::copy_file(rootpath / "apps_rw/test_pkg/data/resource_file.txt", - rootpath / "shared_res/test_pkg/new_dir/new_dir2/resource_file.txt"); - } - virtual void TearDown() { - bf::remove_all("./tests/unit_tests/rsc-copy/data/shared_res/test_pkg"); - } - - std::string root_path = "./tests/unit_tests/rsc-copy/data"; -}; - -class UninstallRequestHandlerTest : public TestFixture { - public: - UninstallRequestHandlerTest() : TestFixture(std::make_unique()) {} - virtual ~UninstallRequestHandlerTest() {} - - virtual void SetUp() { - bf::path rootpath(root_path); - bf::create_directories( - rootpath / "shared_res/test_pkg"); - } - virtual void TearDown() { - bf::remove_all("./tests/unit_tests/rsc-copy/data/shared_res/test_pkg"); - } - - std::string root_path = "./tests/unit_tests/rsc-copy/data"; -}; - -TEST_F(CopyRequestHandlerTest, CopyFileAtRootToRoot) { - std::list path_list; - path_list.emplace_back("data/resource_file.txt", ""); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtRootToRoot_ChangeFileName) { - std::list path_list; - path_list.emplace_back("data/resource_file.txt", "another_name.txt"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "another_name.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtRootToDirectory) { - std::list path_list; - path_list.emplace_back("data/resource_file.txt", "dest_dir"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "dest_dir"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtRootToDirectory_ChangeFileName) { - std::list path_list; - path_list.emplace_back("data/resource_file.txt", "dest_dir/newname.txt"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "dest_dir"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "newname.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToRoot) { - std::list path_list; - path_list.emplace_back("data/resource_dir1/resource_file3.txt", ""); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file3.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToRoot_ChangeFileName) { - std::list path_list; - path_list.emplace_back( - "data/resource_dir1/resource_file3.txt", "newname.txt"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "newname.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToDirectory) { - std::list path_list; - path_list.emplace_back("data/resource_dir1/resource_file3.txt", "dest_dir"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "dest_dir"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file3.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyFileAtDirectoryToDirectory_ChangeFileName) { - std::list path_list; - path_list.emplace_back( - "data/resource_dir1/resource_file3.txt", "dest_dir/newname.txt"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "dest_dir"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "newname.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToRoot) { - std::list path_list; - path_list.emplace_back("data/resource_dir1", ""); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file3.txt"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path = check_path.parent_path(); - check_path /= "resource_dir2"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file2.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToDirectory) { - std::list path_list; - path_list.emplace_back("data/resource_dir1", "dest_dir"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "dest_dir"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file3.txt"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path = check_path.parent_path(); - check_path /= "resource_dir2"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file2.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyDirectoryAtRootToDirectory2) { - std::list path_list; - path_list.emplace_back("data/resource_dir1", "resource_dir1"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_dir1"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file3.txt"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path = check_path.parent_path(); - check_path /= "resource_dir2"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file2.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyDirectoryAtDirectoryToRoot) { - std::list path_list; - path_list.emplace_back("data/resource_dir1/resource_dir2", ""); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file2.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, CopyDirectoryAtDirectoryToDirectory) { - std::list path_list; - path_list.emplace_back("data/resource_dir1/resource_dir2", "dest_dir"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg"); - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "dest_dir"; - EXPECT_TRUE(bf::exists(check_path)); - - check_path /= "resource_file2.txt"; - EXPECT_TRUE(bf::exists(check_path)); -} - -TEST_F(CopyRequestHandlerTest, RscNotexists) { - std::list path_list; - path_list.emplace_back("data/not_existed_rsc", "new_dir"); - CopyRequestHandler handler("test_pkg", root_path, path_list); - - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_RES_NOT_FOUND); -} - -TEST_F(CopyRequestHandlerTest, ReplaceRsc) { - std::list path_list; - path_list.emplace_back("data/resource_file.txt", "new_dir"); - - CopyRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - CopyRequestHandler replace_handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); -} - -TEST_F(RemoveRequestHandlerTest, RemoveFileAtRoot) { - std::list path_list; - path_list.emplace_back("resource_file.txt", ""); - - RemoveRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg/resource_file.txt"); - EXPECT_FALSE(bf::exists(check_path)); -} - -TEST_F(RemoveRequestHandlerTest, RemoveFileAtDirectory) { - std::list path_list; - path_list.emplace_back("new_dir/resource_file.txt", ""); - - RemoveRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path( - root_path + "/shared_res/test_pkg/new_dir/resource_file.txt"); - EXPECT_FALSE(bf::exists(check_path)); -} - -TEST_F(RemoveRequestHandlerTest, RemoveDirectoryAtRoot) { - std::list path_list; - path_list.emplace_back("new_dir", ""); - - RemoveRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg/new_dir"); - EXPECT_FALSE(bf::exists(check_path)); -} - -TEST_F(RemoveRequestHandlerTest, RemoveDirectoryAtDirectory) { - std::list path_list; - path_list.emplace_back("new_dir/new_dir2", ""); - - RemoveRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg/new_dir/new_dir2"); - EXPECT_FALSE(bf::exists(check_path)); -} - -TEST_F(UninstallRequestHandlerTest, RemoveRootPath) { - std::list path_list; - - UninstallRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); - - bf::path check_path(root_path + "/shared_res/test_pkg/"); - EXPECT_FALSE(bf::exists(check_path)); -} - -TEST_F(UninstallRequestHandlerTest, RootNotExists) { - std::list path_list; - bf::path check_path(root_path + "/shared_res/test_pkg/"); - bf::remove_all(check_path); - - UninstallRequestHandler handler("test_pkg", root_path, path_list); - EXPECT_EQ(handler.Execute(), rsc_handler::ErrorType::ERROR_NONE); -} - -TEST_F(UninstallRequestHandlerTest, EmptyPkgID) { - std::list path_list; - - UninstallRequestHandler handler("", root_path, path_list); - EXPECT_EQ(handler.Execute(), - rsc_handler::ErrorType::ERROR_INVALID_PARAMETER); -} diff --git a/tests/unit_tests/rsc-copy/src/test_request_handler_invoker.cc b/tests/unit_tests/rsc-copy/src/test_request_handler_invoker.cc deleted file mode 100644 index 24316c7..0000000 --- a/tests/unit_tests/rsc-copy/src/test_request_handler_invoker.cc +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * 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 -#include -#include - -#include - -#include "mock/os_mock.h" -#include "mock/pkgmgr_info_mock.h" -#include "mock/test_fixture.h" -#include "include/event_signal_sender.hh" -#include "include/param_checker.hh" -#include "include/request_handler_invoker.hh" -#include "include/request_type.hh" - -using ::testing::_; -using ::testing::DoAll; -using ::testing::Invoke; -using ::testing::Return; -using ::testing::SetArgPointee; -using ::testing::InvokeArgument; -using ::testing::SaveArg; - -using rsc_handler::ParamChecker; -using rsc_handler::RequestHandlerInvoker; - -class Mocks : public ::testing::NiceMock, - public ::testing::NiceMock {}; - -class RequestHandlerInvokerTest : public TestFixture { - public: - RequestHandlerInvokerTest() : TestFixture(std::make_unique()) { - signal_sender_.SetPkgID("org.tizen.targepkgid"); - signal_sender_.SetReqType(rsc_handler::ReqType::REQ_TYPE_UNKNOWN); - } - virtual ~RequestHandlerInvokerTest() {} - - virtual void SetUp() {} - virtual void TearDown() {} - - rsc_handler::EventSignalSender signal_sender_; -}; - -TEST_F(RequestHandlerInvokerTest, CopyType) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--copy", - "org.test.targetpkgid", "-p", "srcpath", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - - RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); - EXPECT_EQ(request_handler_invoker.GetHandlerType(), "copy"); - -} - -TEST_F(RequestHandlerInvokerTest, RemoveType) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--remove", - "org.test.targetpkgid", "-p", "", "dstpath", nullptr}; - ParamChecker checker(8, (char**)argv); - - RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); - EXPECT_EQ(request_handler_invoker.GetHandlerType(), "remove"); -} - -TEST_F(RequestHandlerInvokerTest, UninstallType) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", "--delete", - "org.test.targetpkgid", nullptr}; - ParamChecker checker(5, (char**)argv); - - RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); - EXPECT_EQ(request_handler_invoker.GetHandlerType(), "delete"); -} - -TEST_F(RequestHandlerInvokerTest, InvalidType) { - const char *argv[] = { "/bin/rsc-copy", "--uid", "5001", nullptr}; - ParamChecker checker(3, (char**)argv); - - RequestHandlerInvoker request_handler_invoker(checker, signal_sender_); - EXPECT_EQ(request_handler_invoker.GetHandlerType(), ""); - EXPECT_EQ(request_handler_invoker.Execute(), false); -}