diff --git a/frameworks/native/backup_ext/src/ext_backup.cpp b/frameworks/native/backup_ext/src/ext_backup.cpp index 92e37c8b70cca78cc93f9781285974a70d349fb6..e75dcf5f8a792c6627b77713975cc0495c2ed649 100644 --- a/frameworks/native/backup_ext/src/ext_backup.cpp +++ b/frameworks/native/backup_ext/src/ext_backup.cpp @@ -238,6 +238,10 @@ void ExtBackup::OnDisconnect(const AAFwk::Want &want) bool ExtBackup::WasFromSpecialVersion(void) { + if (appVersionStr_.empty()) { + HILOGE("App version name is empty"); + return false; + } std::string appVersionFlag_ = appVersionStr_.substr(0, appVersionStr_.find_first_of(BConstants::VERSION_NAME_SEPARATOR_CHAR)); if (appVersionFlag_ == BConstants::DEFAULT_VERSION_NAME) { @@ -248,6 +252,10 @@ bool ExtBackup::WasFromSpecialVersion(void) bool ExtBackup::SpecialVersionForCloneAndCloud(void) { + if (appVersionStr_.empty()) { + HILOGE("App version name is empty"); + return false; + } std::string appVersionFlag_ = appVersionStr_.substr(0, appVersionStr_.find_first_of(BConstants::VERSION_NAME_SEPARATOR_CHAR)); auto iter = diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h index c2cdd6afbd8bfcc725ffcfd90e0913e3c9760162..cc416af152ebfc647c596d76d1eef25a4822bebe 100644 --- a/services/backup_sa/include/module_ipc/service.h +++ b/services/backup_sa/include/module_ipc/service.h @@ -25,6 +25,7 @@ #include "b_json/b_json_service_disposal_config.h" #include "i_service_reverse.h" #include "iremote_stub.h" +#include "module_ipc/svc_backup_connection.h" #include "module_sched/sched_scheduler.h" #include "service_stub.h" #include "svc_session_manager.h" @@ -333,7 +334,7 @@ private: /** * @brief 验证调用者并返回名称 * - * @return std::string + * @return ErrCode */ ErrCode VerifyCallerAndGetCallerName(std::string &bundleName); @@ -550,7 +551,7 @@ private: void ClearFailedBundles(); void CreateDirIfNotExist(const std::string &path); - + void GetOldDeviceBackupVersion(); std::vector GetSupportBackupBundleNames(vector &bundleInfos, @@ -568,6 +569,12 @@ private: void CancelTask(std::string bundleName, wptr ptr); void SetUserIdAndRestoreType(RestoreTypeEnum restoreType, int32_t userId); + + bool HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup); + + bool HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup); + + void StartCurBundleBackupOrRestore(const std::string &bundleName); private: static sptr instance_; static std::mutex instanceLock_; diff --git a/services/backup_sa/include/module_ipc/svc_session_manager.h b/services/backup_sa/include/module_ipc/svc_session_manager.h index 51b13b07e3dec52b377c4238becdf28126e0390e..2946179f3ecf43576fc9b765c8d44abd3fb61015 100644 --- a/services/backup_sa/include/module_ipc/svc_session_manager.h +++ b/services/backup_sa/include/module_ipc/svc_session_manager.h @@ -560,7 +560,7 @@ private: * @param bundleName 应用名称 * @return std::map::iterator */ - std::map::iterator GetBackupExtNameMap(const std::string &bundleName); + std::tuple::iterator> GetBackupExtNameMap(const std::string &bundleName); /** * @brief 计算出应用程序处理数据可能使用的时间 diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp index 35059ea9a7a29708a1f91026b57e2e7e2cf59ff0..e7ee851d8d49212e4505c2e3dff21e5e399f08fd 100644 --- a/services/backup_sa/src/module_ipc/service.cpp +++ b/services/backup_sa/src/module_ipc/service.cpp @@ -305,7 +305,6 @@ UniqueFd Service::GetLocalCapabilities() return UniqueFd(-EPERM); } BJsonCachedEntity cachedEntity(std::move(fd)); - auto cache = cachedEntity.Structuralize(); std::string backupVersion = BJsonUtil::ParseBackupVersion(); cache.SetBackupVersion(backupVersion); @@ -462,75 +461,58 @@ ErrCode Service::VerifyCaller(IServiceReverse::Scenario scenario) HILOGE("Verify bundle by scenario failed, ret:%{public}d", ret); return ret; } - ret = VerifyCaller(); - return ret; + return VerifyCaller(); } ErrCode Service::InitRestoreSession(sptr remote) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - ErrCode ret = VerifyCaller(); - if (ret != ERR_OK) { - HILOGE("Init restore session failed, verify caller failed"); - return ret; - } - ret = session_->Active({ - .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::RESTORE, - .clientProxy = remote, - .userId = GetUserIdDefault(), - }); - if (ret == 0) { - ClearFailedBundles(); - successBundlesNum_ = 0; - } + ErrCode ret = VerifyCaller(); + if (ret != ERR_OK) { + HILOGE("Init restore session failed, verify caller failed"); return ret; - } catch (const BError &e) { + } + ret = session_->Active({ + .clientToken = IPCSkeleton::GetCallingTokenID(), + .scenario = IServiceReverse::Scenario::RESTORE, + .clientProxy = remote, + .userId = GetUserIdDefault(), + }); + if (ret != ERR_OK) { + HILOGE("Active restore session error, Already have a session"); StopAll(nullptr, true); - return e.GetCode(); - } catch (const exception &e) { - HILOGI("Catched an unexpected low-level exception %{public}s", e.what()); - return EPERM; - } catch (...) { - HILOGI("Unexpected exception"); - return EPERM; + return ret; } + ClearFailedBundles(); + successBundlesNum_ = 0; + return BError(BError::Codes::OK); } ErrCode Service::InitBackupSession(sptr remote) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - ErrCode ret = VerifyCaller(); - if (ret != ERR_OK) { - HILOGE("Init Full Backup session fail, verify caller failed"); - return ret; - } - int32_t oldSize = StorageMgrAdapter::UpdateMemPara(BConstants::BACKUP_VFS_CACHE_PRESSURE); - HILOGE("InitBackupSession oldSize %{public}d", oldSize); - session_->SetMemParaCurSize(oldSize); - ret = session_->Active({ - .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::BACKUP, - .clientProxy = remote, - .userId = GetUserIdDefault(), - }); - if (ret == 0) { - ClearFailedBundles(); - successBundlesNum_ = 0; - } + ErrCode ret = VerifyCaller(); + if (ret != ERR_OK) { + HILOGE("Init Full Backup session fail, verify caller failed"); return ret; - } catch (const BError &e) { + } + int32_t oldSize = StorageMgrAdapter::UpdateMemPara(BConstants::BACKUP_VFS_CACHE_PRESSURE); + HILOGE("InitBackupSession oldSize %{public}d", oldSize); + session_->SetMemParaCurSize(oldSize); + ret = session_->Active({ + .clientToken = IPCSkeleton::GetCallingTokenID(), + .scenario = IServiceReverse::Scenario::BACKUP, + .clientProxy = remote, + .userId = GetUserIdDefault(), + }); + if (ret != ERR_OK) { + HILOGE("Active backup session error, Already have a session"); StopAll(nullptr, true); - return e.GetCode(); - } catch (const exception &e) { - HILOGI("Catched an unexpected low-level exception %{public}s", e.what()); - return EPERM; - } catch (...) { - HILOGI("Unexpected exception"); - return EPERM; + return ret; } + ClearFailedBundles(); + successBundlesNum_ = 0; + return BError(BError::Codes::OK); } ErrCode Service::Start() @@ -1014,11 +996,13 @@ void Service::NotifyCloneBundleFinish(std::string bundleName, const BackupRestor std::lock_guard lock(mutexPtr->callbackMutex); auto backUpConnection = session_->GetExtConnection(bundleName); if (backUpConnection == nullptr) { - throw BError(BError::Codes::SA_INVAL_ARG, "backUpConnection is empty"); + HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); + return; } auto proxy = backUpConnection->GetBackupExtProxy(); if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); + HILOGE("Extension backup Proxy is empty, bundle:%{public}s", bundleName.c_str()); + return; } proxy->HandleClear(); session_->StopFwkTimer(bundleName); @@ -1064,8 +1048,7 @@ ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName) } ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); if (ret != ERR_OK) { - HILOGE("GetFileHandle error, verify caller failed, bundleName:%{public}s, fileName:%{public}s", - bundleName.c_str(), GetAnonyPath(fileName).c_str()); + HILOGE("verify caller failed, bundleName:%{public}s", bundleName.c_str()); return ret; } bool updateRes = SvcRestoreDepsManager::GetInstance().UpdateToRestoreBundleMap(bundleName, fileName); @@ -1073,10 +1056,14 @@ ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName) return BError(BError::Codes::OK); } auto action = session_->GetServiceSchedAction(bundleName); + if (action == BConstants::ServiceSchedAction::UNKNOWN) { + HILOGE("get action failed, bundleName:%{public}s", bundleName.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } if (action == BConstants::ServiceSchedAction::RUNNING) { auto backUpConnection = session_->GetExtConnection(bundleName); if (backUpConnection == nullptr) { - HILOGE("GetFileHandle error, backUpConnection is empty"); + HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); return BError(BError::Codes::SA_INVAL_ARG); } auto proxy = backUpConnection->GetBackupExtProxy(); @@ -1099,9 +1086,6 @@ ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName) return BError(BError::Codes::OK); } catch (const BError &e) { return e.GetCode(); - } catch (...) { - HILOGI("Unexpected exception"); - return EPERM; } } @@ -1117,28 +1101,51 @@ void Service::ExtStart(const string &bundleName) if (IncrementalBackup(bundleName)) { return; } - IServiceReverse::Scenario scenario = session_->GetScenario(); - auto backUpConnection = session_->GetExtConnection(bundleName); - if (backUpConnection == nullptr) { - throw BError(BError::Codes::SA_INVAL_ARG, "ExtStart bundle task error, backUpConnection is empty"); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "ExtStart bundle task error, Extension backup Proxy is empty"); + StartCurBundleBackupOrRestore(bundleName); + } catch (...) { + HILOGI("Unexpected exception, bundleName: %{public}s", bundleName.c_str()); + ClearSessionAndSchedInfo(bundleName); + NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); + } +} + +void Service::StartCurBundleBackupOrRestore(const std::string &bundleName) +{ + HILOGI("Begin handle current bundle full backup or full restore, bundleName:%{public}s", bundleName.c_str()); + IServiceReverse::Scenario scenario = session_->GetScenario(); + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("Error, backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); + if (scenario == IServiceReverse::Scenario::BACKUP) { + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); + } else if (scenario == IServiceReverse::Scenario::RESTORE) { + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); } + return; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (proxy == nullptr) { + HILOGE("Error, Extension backup Proxy is empty, bundle:%{public}s", bundleName.c_str()); if (scenario == IServiceReverse::Scenario::BACKUP) { - auto ret = proxy->HandleBackup(session_->GetClearDataFlag(bundleName)); - session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); - BundleBeginRadarReport(bundleName, ret, scenario); - if (ret) { - ClearSessionAndSchedInfo(bundleName); - NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); - } - return; + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); + } else if (scenario == IServiceReverse::Scenario::RESTORE) { + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); } - if (scenario != IServiceReverse::Scenario::RESTORE) { - throw BError(BError::Codes::SA_INVAL_ARG, "Failed to scenario"); + return; + } + if (scenario == IServiceReverse::Scenario::BACKUP) { + auto ret = proxy->HandleBackup(session_->GetClearDataFlag(bundleName)); + session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); + BundleBeginRadarReport(bundleName, ret, scenario); + if (ret) { + ClearSessionAndSchedInfo(bundleName); + NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); } + } else if (scenario == IServiceReverse::Scenario::RESTORE) { auto ret = proxy->HandleRestore(session_->GetClearDataFlag(bundleName)); session_->GetServiceReverseProxy()->RestoreOnBundleStarted(ret, bundleName); GetOldDeviceBackupVersion(); @@ -1150,11 +1157,8 @@ void Service::ExtStart(const string &bundleName) session_->GetServiceReverseProxy()->RestoreOnFileReady(bundleName, fileName, move(fd), errCode); FileReadyRadarReport(bundleName, fileName, errCode, scenario); } - } catch (...) { - HILOGI("Unexpected exception, bundleName: %{public}s", bundleName.c_str()); - ClearSessionAndSchedInfo(bundleName); - NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); } + HILOGI("End handle current bundle full backup or full restore, bundleName:%{public}s", bundleName.c_str()); } int Service::Dump(int fd, const vector &args) @@ -1240,8 +1244,13 @@ void Service::ExtConnectDone(string bundleName) HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); try { HILOGE("begin %{public}s", bundleName.data()); - BConstants::ServiceSchedAction curSchedAction = session_->GetServiceSchedAction(bundleName); + if (curSchedAction == BConstants::ServiceSchedAction::UNKNOWN) { + HILOGE("Can not find bundle from this session, bundleName:%{public}s", bundleName.c_str()); + ClearSessionAndSchedInfo(bundleName); + NoticeClientFinish(bundleName, BError(BError::Codes::SA_REFUSED_ACT)); + return; + } if (curSchedAction == BConstants::ServiceSchedAction::CLEAN) { sched_->Sched(bundleName); return; @@ -1545,11 +1554,13 @@ ErrCode Service::ClearResidualBundleData(const std::string &bundleName) } auto backUpConnection = session_->GetExtConnection(bundleName); if (backUpConnection == nullptr) { - throw BError(BError::Codes::SA_INVAL_ARG, "backUpConnection is empty"); + HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); } auto proxy = backUpConnection->GetBackupExtProxy(); if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); + HILOGE("Extension backup Proxy is empty, bundle:%{public}s", bundleName.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); } // 通知ext清理 ErrCode res = proxy->HandleClear(); @@ -1730,9 +1741,9 @@ ErrCode Service::AppendBundlesClearSession(const std::vector &bundle HILOGE("Catched an unexpected low-level exception %{public}s", e.what()); return EPERM; } catch (...) { + HILOGE("Unexpected exception"); HandleExceptionOnAppendBundles(session_, bundleNames, {}); session_->DecreaseSessionCnt(__PRETTY_FUNCTION__); - HILOGE("Unexpected exception"); return EPERM; } } @@ -1789,8 +1800,14 @@ ErrCode Service::UpdateSendRate(std::string &bundleName, int32_t sendRate, bool session_->DecreaseSessionCnt(__PRETTY_FUNCTION__); return BError(BError::Codes::SA_INVAL_ARG); } - auto backupConnection = session_->GetExtConnection(bundleName); - auto proxy = backupConnection->GetBackupExtProxy(); + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); + result = false; + session_->DecreaseSessionCnt(__PRETTY_FUNCTION__); + return BError(BError::Codes::SA_INVAL_ARG); + } + auto proxy = backUpConnection->GetBackupExtProxy(); if (!proxy) { HILOGE("Update send rate fail, extension proxy is empty"); result = false; @@ -1900,13 +1917,9 @@ ErrCode Service::SADone(ErrCode errCode, std::string bundleName) } catch (const BError &e) { ReleaseOnException(); return e.GetCode(); // 任意异常产生，终止监听该任务 - } catch (const exception &e) { - ReleaseOnException(); - HILOGE("Catched an unexpected low-level exception %{public}s", e.what()); - return EPERM; } catch(...) { + HILOGE("Unexpected exception"); ReleaseOnException(); - HILOGE("Unexpected exception"); return EPERM; } } @@ -2014,34 +2027,32 @@ void Service::DoTimeout(wptr ptr, std::string bundleName) } IServiceReverse::Scenario scenario = sessionPtr->GetScenario(); TimeoutRadarReport(scenario, bundleName); - try { - std::shared_ptr mutexPtr = GetExtensionMutex(bundleName); - if (mutexPtr == nullptr) { - HILOGE("extension mutex ptr is nullptr"); + std::shared_ptr mutexPtr = GetExtensionMutex(bundleName); + if (mutexPtr == nullptr) { + HILOGE("extension mutex ptr is nullptr, bundleName:%{public}s", bundleName.c_str()); + return; + } + std::lock_guard lock(mutexPtr->callbackMutex); + if (SAUtils::IsSABundleName(bundleName)) { + auto sessionConnection = sessionPtr->GetSAExtConnection(bundleName); + shared_ptr saConnection = sessionConnection.lock(); + if (saConnection == nullptr) { + HILOGE("Error, saConnection is empty, bundleName:%{public}s", bundleName.c_str()); return; } - std::lock_guard lock(mutexPtr->callbackMutex); - if (SAUtils::IsSABundleName(bundleName)) { - auto sessionConnection = sessionPtr->GetSAExtConnection(bundleName); - shared_ptr saConnection = sessionConnection.lock(); - if (saConnection == nullptr) { - HILOGE("lock sa connection ptr is nullptr"); - return; - } - saConnection->DisconnectBackupSAExt(); - } else { - auto sessionConnection = sessionPtr->GetExtConnection(bundleName); - sessionConnection->DisconnectBackupExtAbility(); + saConnection->DisconnectBackupSAExt(); + } else { + auto sessionConnection = sessionPtr->GetExtConnection(bundleName); + if (sessionConnection == nullptr) { + HILOGE("Error, sessionConnection is empty, bundleName:%{public}s", bundleName.c_str()); + return; } - sessionPtr->StopFwkTimer(bundleName); - sessionPtr->StopExtTimer(bundleName); - thisPtr->ClearSessionAndSchedInfo(bundleName); - thisPtr->NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_TIMEOUT)); - } catch (...) { - HILOGE("Unexpected exception, bundleName: %{public}s", bundleName.c_str()); - thisPtr->ClearSessionAndSchedInfo(bundleName); - thisPtr->NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_TIMEOUT)); + sessionConnection->DisconnectBackupExtAbility(); } + sessionPtr->StopFwkTimer(bundleName); + sessionPtr->StopExtTimer(bundleName); + thisPtr->ClearSessionAndSchedInfo(bundleName); + thisPtr->NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_TIMEOUT)); RemoveExtensionMutex(bundleName); } @@ -2069,15 +2080,11 @@ void Service::DelClearBundleRecord(const std::vector &bundleNames) void Service::ReleaseOnException() { - try { - if (session_->IsOnAllBundlesFinished()) { - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (isInRelease_.load() && (scenario == IServiceReverse::Scenario::RESTORE)) { - SessionDeactive(); - } + if (session_->IsOnAllBundlesFinished()) { + IServiceReverse::Scenario scenario = session_->GetScenario(); + if (isInRelease_.load() && (scenario == IServiceReverse::Scenario::RESTORE)) { + SessionDeactive(); } - } catch (...) { - HILOGE("Unexpected exception"); } } diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp index 7a98a2fc38a24b70e145bfc6358a306fe7379368..8699211e434dcd83ea7d9921013cc761bf136718 100644 --- a/services/backup_sa/src/module_ipc/service_incremental.cpp +++ b/services/backup_sa/src/module_ipc/service_incremental.cpp @@ -314,30 +314,28 @@ ErrCode Service::GetAppLocalListAndDoIncrementalBackup() ErrCode Service::InitIncrementalBackupSession(sptr remote) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - ErrCode errCode = VerifyCaller(); - if (errCode != ERR_OK) { - HILOGE("Init incremental backup session fail, Verify caller failed, errCode:%{public}d", errCode); - return errCode; - } - if (session_ == nullptr) { - HILOGE("Init Incremental backup session error, session is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - errCode = session_->Active({.clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::BACKUP, - .clientProxy = remote, - .userId = GetUserIdDefault(), - .isIncrementalBackup = true}); - if (errCode == 0) { - ClearFailedBundles(); - successBundlesNum_ = 0; - } + ErrCode errCode = VerifyCaller(); + if (errCode != ERR_OK) { + HILOGE("Init incremental backup session fail, Verify caller failed, errCode:%{public}d", errCode); return errCode; - } catch (const BError &e) { + } + if (session_ == nullptr) { + HILOGE("Init Incremental backup session error, session is empty"); + return BError(BError::Codes::SA_INVAL_ARG); + } + errCode = session_->Active({.clientToken = IPCSkeleton::GetCallingTokenID(), + .scenario = IServiceReverse::Scenario::BACKUP, + .clientProxy = remote, + .userId = GetUserIdDefault(), + .isIncrementalBackup = true}); + if (errCode != ERR_OK) { + HILOGE("Active incremental backup session error, Already have a session"); StopAll(nullptr, true); - return e.GetCode(); + return errCode; } + ClearFailedBundles(); + successBundlesNum_ = 0; + return BError(BError::Codes::OK); } vector Service::GetBundleNameByDetails(const std::vector &bundlesToBackup) @@ -459,41 +457,37 @@ void Service::HandleCurGroupIncBackupInfos(vector & ErrCode Service::PublishIncrementalFile(const BFileInfo &fileInfo) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); - if (ret != ERR_OK) { - HILOGE("PublishFile error, verify caller by scenario failed, ret:%{public}d", ret); - return ret; - } - HILOGI("Start get ExtConnection, bundleName:%{public}s", fileInfo.owner.c_str()); - if (!fileInfo.fileName.empty()) { - HILOGE("Forbit to use PublishIncrementalFile with fileName for App"); - return EPERM; - } - if (session_ != nullptr) { - session_->SetPublishFlag(fileInfo.owner); - } - auto backUpConnection = session_->GetExtConnection(fileInfo.owner); - if (backUpConnection == nullptr) { - HILOGE("PublishIncrementalFile error, backUpConnection is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - HILOGE("PublishIncrementalFile error, Extension backup Proxy is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - ret = proxy->PublishIncrementalFile(fileInfo.fileName); - if (ret != ERR_OK) { - HILOGE("Failed to publish file for backup extension, ret:%{public}d", ret); - } + ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + if (ret != ERR_OK) { + HILOGE("Publish incremental file failed, bundleName:%{public}s", fileInfo.owner.c_str()); return ret; - } catch (const BError &e) { - return e.GetCode(); - } catch (...) { - HILOGI("Unexpected exception"); + } + HILOGI("Start get ExtConnection, bundleName:%{public}s", fileInfo.owner.c_str()); + if (!fileInfo.fileName.empty()) { + HILOGE("Forbit to use PublishIncrementalFile with fileName for App"); return EPERM; } + if (session_ == nullptr) { + HILOGE("session is empty, bundleName:%{public}s", fileInfo.owner.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + session_->SetPublishFlag(fileInfo.owner); + auto backUpConnection = session_->GetExtConnection(fileInfo.owner); + if (backUpConnection == nullptr) { + HILOGE("backUpConnection is empty, bundle:%{public}s", fileInfo.owner.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("Publish Incremental file failed, bundleName:%{public}s", fileInfo.owner.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + ret = proxy->PublishIncrementalFile(fileInfo.fileName); + if (ret != ERR_OK) { + HILOGE("Failed to publish file for backup extension, bundleName:%{public}s", fileInfo.owner.c_str()); + return ret; + } + return BError(BError::Codes::OK); } ErrCode Service::PublishSAIncrementalFile(const BFileInfo &fileInfo, UniqueFd fd) @@ -532,33 +526,13 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName, UniqueFd f if (fileName == BConstants::EXT_BACKUP_MANAGE) { fd = session_->OnBundleExtManageInfo(callerName, move(fd)); } - HILOGD("reverse: Will notify IncrementalBackupOnFileReady"); session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(callerName, fileName, move(fd), move(manifestFd), errCode); FileReadyRadarReport(callerName, fileName, errCode, IServiceReverse::Scenario::BACKUP); AuditLog auditLog = { false, "Backup File Ready", "ADD", "", 1, "SUCCESS", "AppIncrementalFileReady", callerName, GetAnonyPath(fileName) }; HiAudit::GetInstance(true).Write(auditLog); - if (session_->OnBundleFileReady(callerName, fileName)) { - auto backUpConnection = session_->GetExtConnection(callerName); - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); - } - // 通知extension清空缓存 - proxy->HandleClear(); - // 清除Timer - session_->StopFwkTimer(callerName); - session_->StopExtTimer(callerName); - // 通知TOOL 备份完成 - HILOGI("reverse: Will notify IncrementalBackupOnBundleFinished"); - session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), - callerName); - BundleEndRadarReport(callerName, BError(BError::Codes::OK), IServiceReverse::Scenario::BACKUP); - // 断开extension - backUpConnection->DisconnectBackupExtAbility(); - ClearSessionAndSchedInfo(callerName); - } + HandleCurBundleFileReady(callerName, fileName, true); OnAllBundlesFinished(BError(BError::Codes::OK)); return BError(BError::Codes::OK); } catch (const BError &e) { @@ -583,30 +557,9 @@ ErrCode Service::AppIncrementalDone(ErrCode errCode) HILOGE("App incremental done fail, ret:%{public}d", ret); return ret; } - HILOGI("callerName is %{public}s, errCode is: %{public}d", callerName.c_str(), errCode); - if (session_->OnBundleFileReady(callerName) || errCode != BError(BError::Codes::OK)) { - std::shared_ptr mutexPtr = GetExtensionMutex(callerName); - if (mutexPtr == nullptr) { - HILOGE("extension mutex ptr is nullptr"); - return BError(BError::Codes::SA_INVAL_ARG, "Extension mutex ptr is null."); - } - std::lock_guard lock(mutexPtr->callbackMutex); - auto tempBackUpConnection = session_->GetExtConnection(callerName); - auto backUpConnection = tempBackUpConnection.promote(); - if (backUpConnection == nullptr) { - return BError(BError::Codes::SA_INVAL_ARG, "Promote backUpConnection ptr is null."); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - return BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); - } - proxy->HandleClear(); - session_->StopFwkTimer(callerName); - session_->StopExtTimer(callerName); - backUpConnection->DisconnectBackupExtAbility(); - ClearSessionAndSchedInfo(callerName); - NotifyCallerCurAppIncrementDone(errCode, callerName); - } + HILOGI("Service AppIncrementalDone start, callerName is %{public}s, errCode is: %{public}d", + callerName.c_str(), errCode); + HandleCurAppDone(errCode, callerName, true); RemoveExtensionMutex(callerName); OnAllBundlesFinished(BError(BError::Codes::OK)); return BError(BError::Codes::OK); @@ -624,47 +577,47 @@ ErrCode Service::AppIncrementalDone(ErrCode errCode) ErrCode Service::GetIncrementalFileHandle(const std::string &bundleName, const std::string &fileName) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - if (session_ == nullptr) { - HILOGE("GetIncrementalFileHandle error, session is empty"); + if (session_ == nullptr) { + HILOGE("GetIncrementalFileHandle error, session is empty"); + return BError(BError::Codes::SA_INVAL_ARG); + } + ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + if (ret != ERR_OK) { + HILOGE("Verify caller failed, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), + GetAnonyPath(fileName).c_str()); + return ret; + } + auto action = session_->GetServiceSchedAction(bundleName); + if (action == BConstants::ServiceSchedAction::UNKNOWN) { + HILOGE("Get action error, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), + GetAnonyPath(fileName).c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + if (action == BConstants::ServiceSchedAction::RUNNING) { + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); return BError(BError::Codes::SA_INVAL_ARG); } - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("GetIncrementalFileHandle failed, bundleName:%{public}s", bundleName.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + ret = proxy->GetIncrementalFileHandle(fileName); if (ret != ERR_OK) { - HILOGE("Verify caller failed, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), - GetAnonyPath(fileName).c_str()); + HILOGE("Ipc error, bundleName:%{public}s, fileName:%{public}s, ret:%{public}d", bundleName.c_str(), + GetAnonyPath(fileName).c_str(), ret); + AppRadar::Info info (bundleName, "", ""); + AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::GetIncrementalFileHandle", + GetUserIdDefault(), BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, ret); return ret; } - auto action = session_->GetServiceSchedAction(bundleName); - if (action == BConstants::ServiceSchedAction::RUNNING) { - auto backUpConnection = session_->GetExtConnection(bundleName); - if (backUpConnection == nullptr) { - HILOGE("GetIncrementalFileHandle error, backUpConnection is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - HILOGE("GetIncrementalFileHandle error, Extension backup Proxy is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - ret = proxy->GetIncrementalFileHandle(fileName); - if (ret != ERR_OK) { - HILOGE("Failed to extension file handle"); - AppRadar::Info info (bundleName, "", ""); - AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::GetIncrementalFileHandle", - GetUserIdDefault(), BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, ret); - } - } else { - SvcRestoreDepsManager::GetInstance().UpdateToRestoreBundleMap(bundleName, fileName); - session_->SetExtFileNameRequest(bundleName, fileName); - } - return BError(BError::Codes::OK); - } catch (const BError &e) { - return e.GetCode(); - } catch (...) { - HILOGI("Unexpected exception"); - return EPERM; + } else { + SvcRestoreDepsManager::GetInstance().UpdateToRestoreBundleMap(bundleName, fileName); + session_->SetExtFileNameRequest(bundleName, fileName); } + return BError(BError::Codes::OK); } bool Service::IncrementalBackup(const string &bundleName) @@ -673,11 +626,15 @@ bool Service::IncrementalBackup(const string &bundleName) IServiceReverse::Scenario scenario = session_->GetScenario(); auto backUpConnection = session_->GetExtConnection(bundleName); if (backUpConnection == nullptr) { - throw BError(BError::Codes::SA_INVAL_ARG, "backUpConnection is empty"); + HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); + NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_DIED)); + return true; } auto proxy = backUpConnection->GetBackupExtProxy(); if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); + HILOGE("Increment backup error, extension proxy is empty, bundleName:%{public}s", bundleName.c_str()); + NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_DIED)); + return true; } if (scenario == IServiceReverse::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { auto ret = proxy->IncrementalOnBackup(session_->GetClearDataFlag(bundleName)); @@ -824,8 +781,7 @@ void Service::CancelTask(std::string bundleName, wptr ptr) } do { std::lock_guard lock(mutexPtr->callbackMutex); - auto tempBackUpConnection = session->GetExtConnection(bundleName); - auto backUpConnection = tempBackUpConnection.promote(); + auto backUpConnection = session->GetExtConnection(bundleName); if (backUpConnection == nullptr) { HILOGE("Promote backUpConnection ptr is null."); break; @@ -857,46 +813,42 @@ ErrCode Service::Cancel(std::string bundleName, int32_t &result) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); HILOGI("Begin, bundle name:%{public}s", bundleName.c_str()); - try { - if (session_ == nullptr) { - HILOGE("Cancel error, session is null"); - return BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK); - } - IServiceReverse::Scenario scenario = session_->GetScenario(); - VerifyCaller(scenario); - auto impl = session_->GetImpl(); - auto it = impl.backupExtNameMap.find(bundleName); - if (it == impl.backupExtNameMap.end()) { - result = BError::BackupErrorCode::E_CANCEL_NO_TASK; - return BError(BError::Codes::OK); - } - auto action = session_->GetServiceSchedAction(bundleName); - auto task = [this, bundleName]() { - try { - CancelTask(bundleName, wptr(this)); - } catch (const BError &e) { - HILOGE("CancelTask failed, errCode = %{public}d", e.GetCode()); - } catch (...) { - HILOGI("Unexpected exception"); - } - }; - if (action == BConstants::ServiceSchedAction::RUNNING) { - threadPool_.AddTask(task); - result = BError(BError::Codes::OK); - return BError(BError::Codes::OK); - } - if (action == BConstants::ServiceSchedAction::CLEAN) { - result = BError::BackupErrorCode::E_CANCEL_NO_TASK; - } else { - result = BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK; - } + if (session_ == nullptr) { + HILOGE("Cancel error, session is null"); + return BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK); + } + IServiceReverse::Scenario scenario = session_->GetScenario(); + ErrCode ret = VerifyCaller(scenario); + if (ret != ERR_OK) { + HILOGE("Verify caller failed, bundleName:%{public}s, scenario:%{public}d", bundleName.c_str(), scenario); + return BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK); + } + auto impl = session_->GetImpl(); + auto it = impl.backupExtNameMap.find(bundleName); + if (it == impl.backupExtNameMap.end()) { + result = BError::BackupErrorCode::E_CANCEL_NO_TASK; return BError(BError::Codes::OK); - } catch (const BError &e) { - HILOGE("Cancel failed, errCode = %{public}d", e.GetCode()); - return e.GetCode(); - } catch (...) { - HILOGI("Unexpected exception"); - return EPERM; } + auto action = session_->GetServiceSchedAction(bundleName); + auto task = [this, bundleName]() { + try { + CancelTask(bundleName, wptr(this)); + } catch (const BError &e) { + HILOGE("CancelTask failed, errCode = %{public}d", e.GetCode()); + } catch (...) { + HILOGE("Unexpected exception"); + } + }; + if (action == BConstants::ServiceSchedAction::RUNNING) { + threadPool_.AddTask(task); + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); + } + if (action == BConstants::ServiceSchedAction::CLEAN) { + result = BError::BackupErrorCode::E_CANCEL_NO_TASK; + } else { + result = BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK; + } + return BError(BError::Codes::OK); } } // namespace OHOS::FileManagement::Backup diff --git a/services/backup_sa/src/module_ipc/sub_service.cpp b/services/backup_sa/src/module_ipc/sub_service.cpp index 774744f416536156b2bbf2e0e1ba3d7539b8e3d3..3dd7d889aea1c84a473cb7c0a0aa6317e40a9748 100644 --- a/services/backup_sa/src/module_ipc/sub_service.cpp +++ b/services/backup_sa/src/module_ipc/sub_service.cpp @@ -102,41 +102,35 @@ ErrCode Service::Finish() ErrCode Service::PublishFile(const BFileInfo &fileInfo) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - if (session_ == nullptr) { - HILOGE("PublishFile error, session is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); - if (ret != ERR_OK) { - HILOGE("PublishFile error, verify caller by scenario failed, ret:%{public}d", ret); - return ret; - } - if (!fileInfo.fileName.empty()) { - HILOGE("Forbit to use publishFile with fileName for App"); - return EPERM; - } - auto backUpConnection = session_->GetExtConnection(fileInfo.owner); - if (backUpConnection == nullptr) { - HILOGE("PublishFile error, backUpConnection is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - HILOGE("PublishFile error, Extension backup Proxy is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - ErrCode res = proxy->PublishFile(fileInfo.fileName); - if (res) { - HILOGE("Failed to publish file for backup extension"); - } - return res; - } catch (const BError &e) { - return e.GetCode(); - } catch (...) { - HILOGI("Unexpected exception"); + if (session_ == nullptr) { + HILOGE("PublishFile error, session is empty"); + return BError(BError::Codes::SA_INVAL_ARG); + } + ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + if (ret != ERR_OK) { + HILOGE("PublishFile error, verify caller by scenario failed, ret:%{public}d", ret); + return ret; + } + if (!fileInfo.fileName.empty()) { + HILOGE("Forbit to use publishFile with fileName for App"); return EPERM; } + auto backUpConnection = session_->GetExtConnection(fileInfo.owner); + if (backUpConnection == nullptr) { + HILOGE("backUpConnection is empty, bundle:%{public}s", fileInfo.owner.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("PublishFile error, Extension backup Proxy is empty"); + return BError(BError::Codes::SA_INVAL_ARG); + } + ret = proxy->PublishFile(fileInfo.fileName); + if (ret != ERR_OK) { + HILOGE("Failed to publish file for backup extension, ret:%{public}d", ret); + return ret; + } + return BError(BError::Codes::OK); } ErrCode Service::AppFileReady(const string &fileName, UniqueFd fd, int32_t errCode) @@ -162,29 +156,10 @@ ErrCode Service::AppFileReady(const string &fileName, UniqueFd fd, int32_t errCo } session_->GetServiceReverseProxy()->BackupOnFileReady(callerName, fileName, move(fd), errCode); FileReadyRadarReport(callerName, fileName, errCode, session_->GetScenario()); - if (session_->OnBundleFileReady(callerName, fileName)) { - auto backUpConnection = session_->GetExtConnection(callerName); - if (backUpConnection == nullptr) { - HILOGE("AppFileReady error, backUpConnection is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - HILOGE("AppFileReady error, Extension backup Proxy is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - // 通知extension清空缓存 - proxy->HandleClear(); - // 清除Timer - session_->StopFwkTimer(callerName); - session_->StopExtTimer(callerName); - // 通知TOOL 备份完成 - session_->GetServiceReverseProxy()->BackupOnBundleFinished(BError(BError::Codes::OK), callerName); - BundleEndRadarReport(callerName, BError(BError::Codes::OK), session_->GetScenario()); - // 断开extension - backUpConnection->DisconnectBackupExtAbility(); - ClearSessionAndSchedInfo(callerName); - } + AuditLog auditLog = { false, "Backup File Ready", "ADD", "", 1, "SUCCESS", "AppFileReady", + callerName, GetAnonyPath(fileName) }; + HiAudit::GetInstance(true).Write(auditLog); + HandleCurBundleFileReady(callerName, fileName, false); OnAllBundlesFinished(BError(BError::Codes::OK)); return BError(BError::Codes::OK); } catch (const BError &e) { @@ -210,29 +185,7 @@ ErrCode Service::AppDone(ErrCode errCode) return ret; } HILOGI("Begin, callerName is: %{public}s, errCode: %{public}d", callerName.c_str(), errCode); - if (session_->OnBundleFileReady(callerName) || errCode != BError(BError::Codes::OK)) { - std::shared_ptr mutexPtr = GetExtensionMutex(callerName); - if (mutexPtr == nullptr) { - HILOGE("extension mutex ptr is nullptr"); - return BError(BError::Codes::SA_INVAL_ARG); - } - std::lock_guard lock(mutexPtr->callbackMutex); - auto backUpConnection = session_->GetExtConnection(callerName); - if (backUpConnection == nullptr) { - HILOGE("App finish error, backUpConnection is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); - } - proxy->HandleClear(); - session_->StopFwkTimer(callerName); - session_->StopExtTimer(callerName); - backUpConnection->DisconnectBackupExtAbility(); - ClearSessionAndSchedInfo(callerName); - NotifyCallerCurAppDone(errCode, callerName); - } + HandleCurAppDone(errCode, callerName, false); RemoveExtensionMutex(callerName); OnAllBundlesFinished(BError(BError::Codes::OK)); return BError(BError::Codes::OK); @@ -250,47 +203,42 @@ ErrCode Service::AppDone(ErrCode errCode) ErrCode Service::LaunchBackupExtension(const BundleName &bundleName) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - try { - HILOGI("begin %{public}s", bundleName.data()); - IServiceReverse::Scenario scenario = session_->GetScenario(); - BConstants::ExtensionAction action; - if (scenario == IServiceReverse::Scenario::BACKUP || scenario == IServiceReverse::Scenario::CLEAN) { - action = BConstants::ExtensionAction::BACKUP; - } else if (scenario == IServiceReverse::Scenario::RESTORE) { - action = BConstants::ExtensionAction::RESTORE; - } else { - HILOGE("Get scenario failed, scenario is:%{public}d", scenario); - return BError(BError::Codes::SA_INVAL_ARG); - } - if (SAUtils::IsSABundleName(bundleName)) { - return LaunchBackupSAExtension(bundleName); - } - AAFwk::Want want; - SetWant(want, bundleName, action); - auto backUpConnection = session_->GetExtConnection(bundleName); - if (backUpConnection == nullptr) { - HILOGE("LaunchBackupExtension error, backUpConnection is empty"); - return BError(BError::Codes::SA_INVAL_ARG); - } - if (backUpConnection->IsExtAbilityConnected() && !backUpConnection->WaitDisconnectDone()) { - HILOGE("LaunchBackupExtension error, WaitDisconnectDone failed"); - return BError(BError::Codes::SA_INVAL_ARG); - } - BConstants::ServiceSchedAction bundleAction = session_->GetServiceSchedAction(bundleName); - ErrCode ret = backUpConnection->ConnectBackupExtAbility(want, session_->GetSessionUserId(), - bundleAction == BConstants::ServiceSchedAction::CLEAN); - if (ret) { - HILOGE("ConnectBackupExtAbility faild, bundleName:%{public}s, ret:%{public}d", bundleName.c_str(), ret); - ExtensionConnectFailRadarReport(bundleName, ret, scenario); - return BError(BError::Codes::SA_BOOT_EXT_FAIL); - } - return BError(BError::Codes::OK); - } catch (const BError &e) { - return e.GetCode(); - } catch (...) { - HILOGI("Unexpected exception"); - return EPERM; + HILOGI("begin %{public}s", bundleName.data()); + IServiceReverse::Scenario scenario = session_->GetScenario(); + BConstants::ExtensionAction action; + if (scenario == IServiceReverse::Scenario::BACKUP || scenario == IServiceReverse::Scenario::CLEAN) { + action = BConstants::ExtensionAction::BACKUP; + } else if (scenario == IServiceReverse::Scenario::RESTORE) { + action = BConstants::ExtensionAction::RESTORE; + } else { + action = BConstants::ExtensionAction::INVALID; + HILOGE("Launch current bundle backupExtension failed, action is unknown, bundleName:%{public}s", + bundleName.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + if (SAUtils::IsSABundleName(bundleName)) { + return LaunchBackupSAExtension(bundleName); + } + AAFwk::Want want; + SetWant(want, bundleName, action); + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("LaunchBackupExtension error, backUpConnection is empty"); + return BError(BError::Codes::SA_INVAL_ARG); } + if (backUpConnection->IsExtAbilityConnected() && !backUpConnection->WaitDisconnectDone()) { + HILOGE("LaunchBackupExtension error, WaitDisconnectDone failed"); + return BError(BError::Codes::SA_INVAL_ARG); + } + BConstants::ServiceSchedAction bundleAction = session_->GetServiceSchedAction(bundleName); + ErrCode ret = backUpConnection->ConnectBackupExtAbility(want, session_->GetSessionUserId(), + bundleAction == BConstants::ServiceSchedAction::CLEAN); + if (ret != ERR_OK) { + HILOGE("ConnectBackupExtAbility failed, bundleName:%{public}s, ret:%{public}d", bundleName.c_str(), ret); + ExtensionConnectFailRadarReport(bundleName, ret, scenario); + return BError(BError::Codes::SA_BOOT_EXT_FAIL); + } + return BError(BError::Codes::OK); } void Service::SetWant(AAFwk::Want &want, const BundleName &bundleName, const BConstants::ExtensionAction &action) @@ -500,4 +448,73 @@ void Service::OnAllBundlesFinished(ErrCode errCode) } HILOGI("called end."); } -} \ No newline at end of file + +bool Service::HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup) +{ + if (session_->OnBundleFileReady(bundleName, fileName)) { + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("AppFileReady error, backUpConnection is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("AppFileReady error, Extension backup Proxy is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + // 通知extension清空缓存 + proxy->HandleClear(); + // 清除Timer + session_->StopFwkTimer(bundleName); + session_->StopExtTimer(bundleName); + // 通知TOOL 备份完成 + if (isIncBackup) { + session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), + bundleName); + } else { + session_->GetServiceReverseProxy()->BackupOnBundleFinished(BError(BError::Codes::OK), bundleName); + } + BundleEndRadarReport(bundleName, BError(BError::Codes::OK), session_->GetScenario()); + // 断开extension + backUpConnection->DisconnectBackupExtAbility(); + ClearSessionAndSchedInfo(bundleName); + return true; + } + return false; +} + +bool Service::HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup) +{ + bool fileReadySucc = session_->OnBundleFileReady(bundleName); + if (fileReadySucc || errCode != BError(BError::Codes::OK)) { + std::shared_ptr mutexPtr = GetExtensionMutex(bundleName); + if (mutexPtr == nullptr) { + HILOGE("extension mutex ptr is nullptr, bundleName:%{public}s", bundleName.c_str()); + return false; + } + std::lock_guard lock(mutexPtr->callbackMutex); + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("App finish error, backUpConnection is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("App finish error, Extension backup Proxy is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + proxy->HandleClear(); + session_->StopFwkTimer(bundleName); + session_->StopExtTimer(bundleName); + backUpConnection->DisconnectBackupExtAbility(); + ClearSessionAndSchedInfo(bundleName); + if (isIncBackup) { + NotifyCallerCurAppIncrementDone(errCode, bundleName); + } else { + NotifyCallerCurAppDone(errCode, bundleName); + } + return true; + } + return false; +} +} diff --git a/services/backup_sa/src/module_ipc/svc_session_manager.cpp b/services/backup_sa/src/module_ipc/svc_session_manager.cpp index 0c76366328f2352a4de45ffd70ce0eb39eb0f087..4e7f56fc63bbbd3644068df55b7f1b8375825ad6 100644 --- a/services/backup_sa/src/module_ipc/svc_session_manager.cpp +++ b/services/backup_sa/src/module_ipc/svc_session_manager.cpp @@ -184,16 +184,15 @@ bool SvcSessionManager::OnBundleFileReady(const string &bundleName, const string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("OnBundleFileReady failed, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), + GetAnonyPath(fileName).c_str()); + return false; } - HILOGD("Begin, bundleName name is:%{public}s", bundleName.c_str()); - auto it = impl_.backupExtNameMap.find(bundleName); - if (it == impl_.backupExtNameMap.end()) { - stringstream ss; - ss << "Could not find the " << bundleName << " from current session"; - throw BError(BError::Codes::SA_REFUSED_ACT, ss.str()); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find the bundle:%{public}s", bundleName.c_str()); + return false; } - // 判断是否结束 通知EXTENTION清理资源 TOOL应用完成备份 if (impl_.scenario == IServiceReverse::Scenario::RESTORE || SAUtils::IsSABundleName(bundleName)) { it->second.isBundleFinished = true; @@ -220,10 +219,12 @@ bool SvcSessionManager::OnBundleFileReady(const string &bundleName, const string UniqueFd SvcSessionManager::OnBundleExtManageInfo(const string &bundleName, UniqueFd fd) { if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return UniqueFd(-EPERM); } if (impl_.scenario != IServiceReverse::Scenario::BACKUP) { - throw BError(BError::Codes::SA_INVAL_ARG, "Invalid Scenario"); + HILOGE("Invalid Scenario, bundleName:%{public}s", bundleName.c_str()); + return UniqueFd(-EPERM); } BJsonCachedEntity cachedEntity(move(fd)); @@ -231,12 +232,16 @@ UniqueFd SvcSessionManager::OnBundleExtManageInfo(const string &bundleName, Uniq auto info = cache.GetExtManage(); for (auto &fileName : info) { - HILOGE("fileName %{public}s", GetAnonyString(fileName).data()); + HILOGE("fileName %{public}s", GetAnonyPath(fileName).data()); OnBundleFileReady(bundleName, fileName); } unique_lock lock(lock_); - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find the bundle:%{public}s", bundleName.c_str()); + return UniqueFd(-EPERM); + } it->second.receExtManageJson = true; return move(cachedEntity.GetFd()); } @@ -247,7 +252,7 @@ void SvcSessionManager::RemoveExtInfo(const string &bundleName) unique_lock lock(lock_); auto it = impl_.backupExtNameMap.find(bundleName); if (it == impl_.backupExtNameMap.end()) { - HILOGI("BackupExtNameMap not contain %{public}s", bundleName.c_str()); + HILOGE("BackupExtNameMap not contain %{public}s", bundleName.c_str()); return; } if (extConnectNum_) { @@ -266,12 +271,18 @@ wptr SvcSessionManager::GetExtConnection(const BundleName & HILOGD("svcMrg:GetExt, bundleName:%{public}s", bundleName.c_str()); shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return nullptr; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find current bundle, bundleName:%{public}s", bundleName.c_str()); + return nullptr; + } if (!it->second.backUpConnection) { - throw BError(BError::Codes::SA_INVAL_ARG, "Svc backup connection is empty"); + HILOGE("Svc backup connection is empty, bundleName:%{public}s", bundleName.c_str()); + return nullptr; } return wptr(it->second.backUpConnection); @@ -282,12 +293,18 @@ std::weak_ptr SvcSessionManager::GetSAExtConnection(const Bu HILOGD("svcMrg:GetExt, bundleName:%{public}s", bundleName.c_str()); shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return std::weak_ptr(); } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find current bundle, bundleName:%{public}s", bundleName.c_str()); + return std::weak_ptr(); + } if (!it->second.saBackupConnection) { - throw BError(BError::Codes::SA_INVAL_ARG, "SA backup connection is empty"); + HILOGE("SA backup connection is empty, bundleName:%{public}s", bundleName.c_str()); + return std::weak_ptr(); } return std::weak_ptr(it->second.saBackupConnection); @@ -382,7 +399,6 @@ ErrCode SvcSessionManager::InitClient(Impl &newImpl) HILOGE("Init client error, Proxy's remote object can't be nullptr"); return BError(BError::Codes::SA_BROKEN_IPC); } - auto callback = [revPtr {reversePtr_}](const wptr &obj) { HILOGI("Client died."); @@ -412,10 +428,14 @@ void SvcSessionManager::SetExtFileNameRequest(const string &bundleName, const st { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find current bundle, bundleName:%{public}s", bundleName.c_str()); + return; } - - auto it = GetBackupExtNameMap(bundleName); it->second.fileNameInfo.insert(fileName); } @@ -423,27 +443,33 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return std::set(); } if (impl_.scenario != IServiceReverse::Scenario::RESTORE) { - throw BError(BError::Codes::SA_INVAL_ARG, "Invalid Scenario"); + HILOGE("Invalid Scenario, bundleName:%{public}s", bundleName.c_str()); + return std::set(); + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return std::set(); } - auto it = GetBackupExtNameMap(bundleName); set fileNameInfo = it->second.fileNameInfo; it->second.fileNameInfo.clear(); return fileNameInfo; } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &bundleName) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap( + const string &bundleName) { auto it = impl_.backupExtNameMap.find(bundleName); if (it == impl_.backupExtNameMap.end()) { - stringstream ss; - ss << "Could not find the " << bundleName << " from current session"; - throw BError(BError::Codes::SA_REFUSED_ACT, ss.str()); + HILOGE("Could not find the bundle from current session, bundleName:%{public}s", bundleName.c_str()); + return {false, impl_.backupExtNameMap.end()}; } - return it; + return {true, it}; } bool SvcSessionManager::GetSchedBundleName(string &bundleName) @@ -473,9 +499,14 @@ BConstants::ServiceSchedAction SvcSessionManager::GetServiceSchedAction(const st { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return BConstants::ServiceSchedAction::UNKNOWN; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return BConstants::ServiceSchedAction::UNKNOWN; } - auto it = GetBackupExtNameMap(bundleName); return it->second.schedAction; } @@ -483,10 +514,14 @@ void SvcSessionManager::SetServiceSchedAction(const string &bundleName, BConstan { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - - auto it = GetBackupExtNameMap(bundleName); it->second.schedAction = action; if (it->second.schedAction == BConstants::ServiceSchedAction::START) { extConnectNum_++; @@ -497,10 +532,15 @@ void SvcSessionManager::SetBackupExtName(const string &bundleName, const string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.backupExtName = backupExtName; } @@ -508,10 +548,15 @@ string SvcSessionManager::GetBackupExtName(const string &bundleName) { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return ""; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return ""; + } return it->second.backupExtName; } @@ -519,10 +564,15 @@ void SvcSessionManager::SetBackupExtInfo(const string &bundleName, const string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.extInfo = extInfo; } @@ -530,10 +580,15 @@ std::string SvcSessionManager::GetBackupExtInfo(const string &bundleName) { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return ""; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return ""; + } return it->second.extInfo; } @@ -541,7 +596,8 @@ void SvcSessionManager::AppendBundles(const vector &bundleNames) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("AppendBundles error, No caller token was specified"); + return; } for (auto &&bundleName : bundleNames) { @@ -599,7 +655,8 @@ bool SvcSessionManager::IsOnAllBundlesFinished() { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("IsOnAllBundlesFinished error, No caller token was specified"); + return false; } bool isAllBundlesFinished = !impl_.backupExtNameMap.size(); if (impl_.scenario == IServiceReverse::Scenario::RESTORE) { @@ -615,7 +672,8 @@ bool SvcSessionManager::IsOnOnStartSched() HILOGI("Begin"); shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("IsOnOnStartSched error, No caller token was specified"); + return false; } if (impl_.isBackupStart && impl_.backupExtNameMap.size()) { return true; @@ -643,10 +701,15 @@ void SvcSessionManager::SetBundleRestoreType(const std::string &bundleName, Rest { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.restoreType = restoreType; } @@ -654,10 +717,15 @@ RestoreTypeEnum SvcSessionManager::GetBundleRestoreType(const std::string &bundl { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; + } return it->second.restoreType; } @@ -665,10 +733,15 @@ void SvcSessionManager::SetBundleVersionCode(const std::string &bundleName, int6 { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.versionCode = versionCode; } @@ -676,10 +749,15 @@ int64_t SvcSessionManager::GetBundleVersionCode(const std::string &bundleName) { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return 0; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return 0; + } return it->second.versionCode; } @@ -687,10 +765,15 @@ void SvcSessionManager::SetBundleVersionName(const std::string &bundleName, std: { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.versionName = versionName; } @@ -698,10 +781,15 @@ std::string SvcSessionManager::GetBundleVersionName(const std::string &bundleNam { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return ""; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return ""; + } return it->second.versionName; } @@ -709,10 +797,15 @@ void SvcSessionManager::SetBundleDataSize(const std::string &bundleName, int64_t { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.dataSize = dataSize; } @@ -726,14 +819,14 @@ uint32_t SvcSessionManager::CalAppProcessTime(const std::string &bundleName) int64_t timeout; uint32_t resTimeoutMs; - try { - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("CalAppProcessTime failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + timeout = defaultTimeout; + } else { int64_t appSize = it->second.dataSize; /* timeout = (AppSize / 3Ms) * 3 + 30 */ timeout = defaultTimeout + (appSize / processRate) * multiple; - } catch (const BError &e) { - HILOGE("Failed to get app<%{public}s> dataInfo, err=%{public}d", bundleName.c_str(), e.GetCode()); - timeout = defaultTimeout; } timeout = timeout < minTimeout ? minTimeout : timeout; resTimeoutMs = (uint32_t)(timeout * invertMillisecond % UINT_MAX); /* conver second to millisecond */ @@ -750,7 +843,11 @@ bool SvcSessionManager::StartFwkTimer(const std::string &bundleName, const Utils HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Start fwk timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.fwkTimerStatus == true) { HILOGE("FwkTimer is registered, unregister first."); return false; @@ -771,7 +868,11 @@ bool SvcSessionManager::StopFwkTimer(const std::string &bundleName) HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Stop fwk timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.fwkTimerStatus == false) { HILOGE("FwkTimer is unregistered, register first."); return true; @@ -791,7 +892,11 @@ bool SvcSessionManager::StartExtTimer(const std::string &bundleName, const Utils HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Start extension timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.extTimerStatus == true) { HILOGE("ExtTimer is registered, unregister first."); return false; @@ -812,7 +917,11 @@ bool SvcSessionManager::StopExtTimer(const std::string &bundleName) HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Stop extension timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.extTimerStatus == false) { HILOGE("ExtTimer is unregistered, register first."); return true; @@ -834,7 +943,11 @@ bool SvcSessionManager::UpdateTimer(const std::string &bundleName, uint32_t time HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Update timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } it->second.timeout = timeout; if (it->second.extTimerStatus == false) { HILOGI("ExtTimer is unregistered, just store timeout %{public}u(ms)", timeout); @@ -907,7 +1020,8 @@ bool SvcSessionManager::GetIsIncrementalBackup() { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("GetIsIncrementalBackup error, No caller token was specified"); + return false; } return impl_.isIncrementalBackup; } @@ -916,9 +1030,14 @@ void SvcSessionManager::SetIncrementalData(const BIncrementalData &incrementalDa { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("SetIncrementalData error, No caller token was specified"); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(incrementalData.bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", incrementalData.bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(incrementalData.bundleName); it->second.lastIncrementalTime = incrementalData.lastIncrementalTime; it->second.manifestFd = incrementalData.manifestFd; it->second.backupParameters = incrementalData.backupParameters; @@ -929,9 +1048,14 @@ int32_t SvcSessionManager::GetIncrementalManifestFd(const string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return BConstants::INVALID_FD_NUM; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return BConstants::INVALID_FD_NUM; } - auto it = GetBackupExtNameMap(bundleName); return it->second.manifestFd; } @@ -939,9 +1063,14 @@ int64_t SvcSessionManager::GetLastIncrementalTime(const string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return 0; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return 0; } - auto it = GetBackupExtNameMap(bundleName); return it->second.lastIncrementalTime; } @@ -959,19 +1088,30 @@ void SvcSessionManager::SetClearDataFlag(const std::string &bundleName, bool isC { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); it->second.isClearData = isClearData; HILOGI("bundleName:%{public}s, set clear data flag:%{public}d.", bundleName.c_str(), isClearData); } + bool SvcSessionManager::GetClearDataFlag(const std::string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return true; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return true; } - auto it = GetBackupExtNameMap(bundleName); return it->second.isClearData; } @@ -1035,9 +1175,14 @@ void SvcSessionManager::SetPublishFlag(const std::string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); it->second.isInPublishFile = true; HILOGE("Set PublishFile success, bundleName = %{public}s", bundleName.c_str()); } @@ -1046,7 +1191,8 @@ void SvcSessionManager::SetOldBackupVersion(const std::string &backupVersion) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("Error, No caller token was specified"); + return; } impl_.oldBackupVersion = backupVersion; } @@ -1055,7 +1201,8 @@ std::string SvcSessionManager::GetOldBackupVersion() { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("Error, No caller token was specified"); + return ""; } return impl_.oldBackupVersion; } @@ -1069,9 +1216,14 @@ void SvcSessionManager::SetIsReadyLaunch(const std::string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); it->second.isReadyLaunch = true; HILOGE("SetIsReadyLaunch success, bundleName = %{public}s", bundleName.c_str()); } diff --git a/tests/mock/module_ipc/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp index 3cdecca0f4c207f92efddf7312b49b907529a813..6159f0b8b91cfabbb3f253b7f1c2d00dd6b80f23 100644 --- a/tests/mock/module_ipc/service_mock.cpp +++ b/tests/mock/module_ipc/service_mock.cpp @@ -316,4 +316,6 @@ void Service::HandleNotSupportBundleNames(const vector&, vector& void Service::SetBundleIncDataInfo(const std::vector&, std::vector&) {} void Service::CancelTask(std::string bundleName, wptr ptr) {} + +void SetUserIdAndRestoreType(RestoreTypeEnum restoreType, int32_t userId) {} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/module_ipc/src/svc_session_manager_mock.cpp b/tests/mock/module_ipc/src/svc_session_manager_mock.cpp index 8739d1da44b6ba0dc8bf9b91fbeb576878ff05e4..dd5cf745673d1817bf485faa71a1f1ef0afbe92f 100644 --- a/tests/mock/module_ipc/src/svc_session_manager_mock.cpp +++ b/tests/mock/module_ipc/src/svc_session_manager_mock.cpp @@ -87,9 +87,9 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string return BSvcSessionManager::sessionManager->GetExtFileNameRequest(bundleName); } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap(const string &) { - return {}; + return {true, {}}; } bool SvcSessionManager::GetSchedBundleName(string &bundleName) diff --git a/tests/mock/module_ipc/svc_session_manager_mock.cpp b/tests/mock/module_ipc/svc_session_manager_mock.cpp index bb61902f8218fb905d5e8c708e50d4602da2d1c8..b5e2a1d1aa565cce177a3a5359409cc1c64a6b8c 100644 --- a/tests/mock/module_ipc/svc_session_manager_mock.cpp +++ b/tests/mock/module_ipc/svc_session_manager_mock.cpp @@ -146,11 +146,15 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string return fileNameInfo; } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &bundleName) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap( + const string &bundleName) { GTEST_LOG_(INFO) << "GetBackupExtNameMap"; auto it = impl_.backupExtNameMap.find(bundleName); - return it; + if (it == impl_.backupExtNameMap.end()) { + return {false, impl_.backupExtNameMap.end()}; + } + return {true, it}; } bool SvcSessionManager::GetSchedBundleName(string &bundleName) diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp index bfdf4a3d5a1365b0ca21874b482793698ae6af97..f1fcc20680542605418a425591fb436f72ebaf25 100644 --- a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp +++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp @@ -94,7 +94,8 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string return BackupSvcSessionManager::session->GetExtFileNameRequest(bundleName); } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &bundleName) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap( + const string &bundleName) { return BackupSvcSessionManager::session->GetBackupExtNameMap(bundleName); } diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.h b/tests/mock/module_ipc/svc_session_manager_throw_mock.h index 2b3154b1aaa89244fe2287cc7ce0329bfa496c6c..081da93b792e1fde9bbf50a4feb0c6f7f045186a 100644 --- a/tests/mock/module_ipc/svc_session_manager_throw_mock.h +++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.h @@ -42,7 +42,8 @@ public: virtual ErrCode InitClient(SvcSessionManager::Impl &) = 0; virtual void SetExtFileNameRequest(const std::string &, const std::string &) = 0; virtual std::set GetExtFileNameRequest(const std::string &) = 0; - virtual std::map::iterator GetBackupExtNameMap(const std::string &) = 0; + virtual std::tuple::iterator> GetBackupExtNameMap( + const std::string &) = 0; virtual bool GetSchedBundleName(std::string &) = 0; virtual BConstants::ServiceSchedAction GetServiceSchedAction(const std::string &) = 0; virtual void SetServiceSchedAction(const std::string &, BConstants::ServiceSchedAction) = 0; @@ -113,7 +114,8 @@ public: MOCK_METHOD(ErrCode, InitClient, (SvcSessionManager::Impl &)); MOCK_METHOD(void, SetExtFileNameRequest, (const std::string &, const std::string &)); MOCK_METHOD(std::set, GetExtFileNameRequest, (const std::string &)); - MOCK_METHOD((std::map::iterator), GetBackupExtNameMap, (const std::string &)); + MOCK_METHOD((std::tuple::iterator>), GetBackupExtNameMap, + (const std::string &)); MOCK_METHOD(bool, GetSchedBundleName, (std::string &)); MOCK_METHOD(BConstants::ServiceSchedAction, GetServiceSchedAction, (const std::string &)); MOCK_METHOD(void, SetServiceSchedAction, (const std::string &, BConstants::ServiceSchedAction)); diff --git a/tests/unittests/backup_sa/module_ipc/BUILD.gn b/tests/unittests/backup_sa/module_ipc/BUILD.gn index f2f80ec7741da6c47652045d5cd6604d2a161324..d6891417596a7b6efac3dbc69dfaa91b4bec65c2 100644 --- a/tests/unittests/backup_sa/module_ipc/BUILD.gn +++ b/tests/unittests/backup_sa/module_ipc/BUILD.gn @@ -163,12 +163,13 @@ ohos_unittest("backup_service_throw_test") { module_out_path = path_module_out_tests sources = [ - "${path_backup_mock}/accesstoken/accesstoken_kit_mock.cpp", + "${path_backup_mock}/accesstoken/src/accesstoken_kit_mock.cpp", "${path_backup_mock}/module_ipc/app_gallery_dispose_proxy_mock.cpp", "${path_backup_mock}/module_ipc/src/ipc_skeleton_mock.cpp", "${path_backup_mock}/module_ipc/svc_session_manager_throw_mock.cpp", "${path_backup_mock}/timer/timer_mock.cpp", "${path_backup_mock}/utils_mock/src/b_jsonutil_mock.cpp", + "${path_backup_mock}/utils_mock/src/backup_para_mock.cpp", "${path_backup}/services/backup_sa/src/module_ipc/sa_backup_connection.cpp", "${path_backup}/services/backup_sa/src/module_ipc/service.cpp", "${path_backup}/services/backup_sa/src/module_ipc/service_incremental.cpp", diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index a96d7c782bb42c7aac29538e685d1a9ada60a815..991bc6ee8ca08f169ca45c67f1965f2ebc097264 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -260,6 +260,18 @@ std::vector Service::GetSupportBackupBundleNames(vectorAppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); @@ -758,15 +770,9 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - ret = service->AppIncrementalDone(errCode); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); - - errCode = BError(BError::Codes::SA_INVAL_ARG).GetCode(); - EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); ret = service->AppIncrementalDone(errCode); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalDone."; @@ -817,7 +823,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); ret = service->GetIncrementalFileHandle(bundleName, fileName); - EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + EXPECT_EQ(ret, 1); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT)); ret = service->GetIncrementalFileHandle(bundleName, fileName); @@ -845,17 +851,19 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, string bundleName; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - EXPECT_THROW(service->IncrementalBackup(bundleName), BError); + auto ret = service->IncrementalBackup(bundleName); + EXPECT_TRUE(ret); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - EXPECT_THROW(service->IncrementalBackup(bundleName), BError); + ret = service->IncrementalBackup(bundleName); + EXPECT_TRUE(ret); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - auto ret = service->IncrementalBackup(bundleName); + ret = service->IncrementalBackup(bundleName); EXPECT_FALSE(ret); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); diff --git a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp index c329924e44dc87782ca012da2763a383b380f4fa..c5c14d10a0ee28dda8732db99e7b0e6d4509767d 100644 --- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp @@ -1173,12 +1173,37 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0100, TestSize.Level1) EXPECT_NE(ret, BError(BError::Codes::OK)); service->session_ = sptr(new SvcSessionManager(wptr(service))); + map bundleMap; + bundleMap["bundleName"] = {.fileNames_ = {"name"}}; + vector bundleInfos = {{.name = "name"}}; + bundleInfos.clear(); + bundleInfos = {{.name = "bundleName"}}; EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); - EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*session, GetScenario()) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); + EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); + EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); + EXPECT_CALL(*depManager, GetAllBundles()).WillOnce(Return(bundleInfos)); + EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, GetServiceReverseProxy()) + .WillOnce(Return(srProxy)) + .WillOnce(Return(srProxy)); + EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); + EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); + EXPECT_CALL(*srProxy, BackupOnAllBundlesFinished(_)).WillOnce(Return()); ret = service->AppDone(errCode); EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { @@ -1210,8 +1235,9 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0200, TestSize.Level1) EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); auto ret = service->AppDone(errCode); - EXPECT_NE(ret, BError(BError::Codes::OK)); + EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); @@ -1222,7 +1248,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0200, TestSize.Level1) EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->AppDone(errCode); - EXPECT_NE(ret, BError(BError::Codes::OK)); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppDone."; @@ -1406,22 +1432,31 @@ HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0100, TestSize.Level1) service->ClearResidualBundleData(bundleName); service->session_ = sptr(new SvcSessionManager(wptr(service))); - try { - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - service->ClearResidualBundleData(bundleName); - EXPECT_TRUE(false); - } catch (...) { - EXPECT_TRUE(true); - } - - try { - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); - EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - service->ClearResidualBundleData(bundleName); - EXPECT_TRUE(false); - } catch (...) { - EXPECT_TRUE(true); - } + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + auto ret = service->ClearResidualBundleData(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); + ret = service->ClearResidualBundleData(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true)); + EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*session, GetScenario()) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, BackupOnAllBundlesFinished(_)).WillOnce(Return()); + ret = service->ClearResidualBundleData(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ClearResidualBundleData."; @@ -1855,10 +1890,19 @@ HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0000, TestSize.Level1) EXPECT_TRUE(true); shared_ptr sa = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()) + .WillOnce(Return(IServiceReverse::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); - EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); + EXPECT_CALL(*saUtils, IsSABundleName(_)) + .WillOnce(Return(true)) + .WillOnce(Return(true)); + EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); + EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); service->DoTimeout(service, bundleName); EXPECT_TRUE(true); diff --git a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp index ba4e5be469068618629a18fbe8244bedb9975d15..61865ff21fc9906bc5008c7244b1155cf3f10065 100644 --- a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp @@ -18,6 +18,7 @@ #include "accesstoken_kit_mock.h" #include "b_jsonutil_mock.h" +#include "backup_para_mock.h" #include "ipc_skeleton_mock.h" #include "module_ipc/service.h" #include "svc_session_manager_throw_mock.h" @@ -28,6 +29,7 @@ using namespace std; using namespace testing; constexpr int32_t SERVICE_ID = 5203; +constexpr int32_t DEBUG_ID = 100; class ServiceThrowTest : public testing::Test { public: @@ -37,6 +39,7 @@ public: void TearDown() {}; static inline sptr service = nullptr; + static inline shared_ptr param = nullptr; static inline shared_ptr sessionMock = nullptr; static inline shared_ptr jsonUtil = nullptr; static inline shared_ptr skeleton = nullptr; @@ -47,6 +50,8 @@ void ServiceThrowTest::SetUpTestCase(void) { GTEST_LOG_(INFO) << "SetUpTestCase enter"; service = sptr(new Service(SERVICE_ID)); + param = make_shared(); + BackupParaMock::backupPara = param; sessionMock = make_shared(); SvcSessionManagerMock::session = sessionMock; jsonUtil = make_shared(); @@ -61,6 +66,8 @@ void ServiceThrowTest::TearDownTestCase() { GTEST_LOG_(INFO) << "TearDownTestCase enter"; service = nullptr; + BackupParaMock::backupPara = nullptr; + param = nullptr; SvcSessionManagerMock::session = nullptr; sessionMock = nullptr; BJsonUtilMock::jsonUtil = nullptr; @@ -124,16 +131,32 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_GetLocalCapabilities_0100, testing: HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitRestoreSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_InitRestoreSession_0100"; - try { - EXPECT_NE(service, nullptr); - EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); - EXPECT_CALL(*sessionMock, Deactive(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); - auto ret = service->InitRestoreSession(nullptr); - EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceThrowTest-an exception occurred by InitRestoreSession."; - } + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::DEFAULT_USER_ID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = service->InitRestoreSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitRestoreSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::OK))); + ret = service->InitRestoreSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitRestoreSession_0100"; } @@ -149,18 +172,32 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitRestoreSession_0100, testing::e HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_InitBackupSession_0100"; - try { - EXPECT_NE(service, nullptr); - EXPECT_CALL(*sessionMock, SetMemParaCurSize(_)).WillOnce(Invoke([]() { - throw BError(BError::Codes::EXT_THROW_EXCEPTION); - })); - EXPECT_CALL(*sessionMock, Deactive(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); - auto ret = service->InitBackupSession(nullptr); - EXPECT_EQ(ret, BError(BError::Codes::EXT_THROW_EXCEPTION).GetCode()); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceThrowTest-an exception occurred by InitBackupSession."; - } + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::DEFAULT_USER_ID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = service->InitBackupSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitBackupSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::OK))); + ret = service->InitBackupSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitBackupSession_0100"; } @@ -328,6 +365,10 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_AppDone_0100, testing::ext::TestSiz GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_AppDone_0100"; try { EXPECT_NE(service, nullptr); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")); EXPECT_CALL(*sessionMock, VerifyBundleName(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); auto ret = service->AppDone(0); @@ -382,11 +423,17 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_GetFileHandle_0100, testing::ext::T string fileName; EXPECT_CALL(*sessionMock, VerifyCallerAndScenario(_, _)).WillOnce( Return(BError(BError::Codes::SDK_MIXED_SCENARIO))); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); auto ret = service->GetFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); EXPECT_CALL(*sessionMock, VerifyCallerAndScenario(_, _)).WillOnce( Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE)); + EXPECT_CALL(*token, VerifyAccessToken(_, _)) + .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); ret = service->GetFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); } catch (...) { @@ -561,52 +608,6 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_UpdateTimer_0100, testing::ext::Tes GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_UpdateTimer_0100"; } -/** - * @tc.number: SUB_Service_throw_SADone_0100 - * @tc.name: SUB_Service_throw_SADone_0100 - * @tc.desc: 测试 SADone 接口的 catch 分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesIAC04T - */ -HWTEST_F(ServiceThrowTest, SUB_Service_throw_SADone_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_SADone_0100"; - try { - EXPECT_NE(service, nullptr); - ErrCode errCode = 0; - string bundleName; - EXPECT_CALL(*sessionMock, OnBundleFileReady(_, _)).WillOnce(Invoke([]() { - throw BError(BError::Codes::EXT_THROW_EXCEPTION); - return false; - })); - EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); - auto ret = service->SADone(errCode, bundleName); - EXPECT_EQ(ret, BError(BError::Codes::EXT_THROW_EXCEPTION).GetCode()); - - EXPECT_CALL(*sessionMock, OnBundleFileReady(_, _)).WillOnce(Invoke([]() { - throw runtime_error("运行时错误"); - return false; - })); - EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); - ret = service->SADone(errCode, bundleName); - EXPECT_EQ(ret, EPERM); - - EXPECT_CALL(*sessionMock, OnBundleFileReady(_, _)).WillOnce(Invoke([]() { - throw "未知错误"; - return false; - })); - EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); - ret = service->SADone(errCode, bundleName); - EXPECT_EQ(ret, EPERM); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceThrowTest-an exception occurred by SADone."; - } - GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_SADone_0100"; -} - /** * @tc.number: SUB_Service_throw_GetLocalCapabilitiesIncremental_0100 * @tc.name: SUB_Service_throw_GetLocalCapabilitiesIncremental_0100 @@ -702,17 +703,35 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_GetAppLocalListAndDoIncrementalBack HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitIncrementalBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_InitIncrementalBackupSession_0100"; - try { - EXPECT_NE(service, nullptr); - EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); - EXPECT_CALL(*sessionMock, Deactive(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); - EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); - auto ret = service->InitIncrementalBackupSession(nullptr); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceThrowTest-an exception occurred by InitIncrementalBackupSession."; - } + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::DEFAULT_USER_ID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = service->InitIncrementalBackupSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitIncrementalBackupSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::OK))); + ret = service->InitIncrementalBackupSession(nullptr); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitIncrementalBackupSession_0100"; } @@ -804,11 +823,13 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_PublishIncrementalFile_0100, testin BFileInfo fileInfo; EXPECT_CALL(*sessionMock, VerifyCallerAndScenario(_, _)).WillOnce( Return(BError(BError::Codes::SDK_MIXED_SCENARIO))); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); auto ret = service->PublishIncrementalFile(fileInfo); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, BError(BError::Codes::SDK_MIXED_SCENARIO).GetCode()); EXPECT_CALL(*sessionMock, VerifyCallerAndScenario(_, _)).WillOnce( Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); ret = service->PublishIncrementalFile(fileInfo); EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); } catch (...) { diff --git a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp index 80f110bdba21b162581b1c7614e2eea6cbdb924d..0bf2bf2f4877b610436d50c290394205a91fd726 100644 --- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp @@ -76,6 +76,7 @@ HWTEST_F(ServiceTest, SUB_Service_ServiceResultReport_0000, TestSize.Level1) EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return()); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp index b8e7eac57c892bd61a123615386bbc3715bcb372..34a4a6fd2216823bbd429f84d2ab528b072a9b7f 100644 --- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp @@ -26,14 +26,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetLastIncrementalTime_010 { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetLastIncrementalTime_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME); + EXPECT_EQ(ret, 0); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp index 888ee90ff01c7ace65272536fd659333dd5b0db3..8de04b42c7c59a21e6116b7a397e718bd418bd85 100644 --- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp @@ -306,49 +306,36 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_getscenario_0100, testing: HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT); - } - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_TRUE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap["123"] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - ret = sessionManagerPtr_->OnBundleFileReady("123"); - EXPECT_TRUE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_FALSE(ret); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by onBundlefileready."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_TRUE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap["123"] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + fileReady = sessionManagerPtr_->OnBundleFileReady("123"); + EXPECT_TRUE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_FALSE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0100"; } @@ -364,40 +351,35 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, te HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0101"; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); - EXPECT_FALSE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "test"); - EXPECT_FALSE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, string(BConstants::EXT_BACKUP_MANAGE)); - EXPECT_FALSE(ret); - - BackupExtInfo info; - info.receExtManageJson = true; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); - EXPECT_TRUE(ret); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by onBundlefileready."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "test"); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, string(BConstants::EXT_BACKUP_MANAGE)); + EXPECT_FALSE(fileReady); + + BackupExtInfo info; + info.receExtManageJson = true; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); + EXPECT_TRUE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0101"; } @@ -413,42 +395,29 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, te HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleExtManageInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_OnBundleExtManageInfo_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - TestManager tm("SvcSessionManagerTest_GetFd_0100"); - string filePath = tm.GetRootDirCurTest().append(MANAGE_JSON); - SaveStringToFile(filePath, R"({"fileName" : "1.tar"})"); - UniqueFd fd(open(filePath.data(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)); - sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, move(fd)); - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_TRUE(ret); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by OnBundleExtManageInfo."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); + EXPECT_TRUE(move(ret) == -1); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); + EXPECT_TRUE(move(ret) == -1); + + TestManager tm("SvcSessionManagerTest_GetFd_0100"); + string filePath = tm.GetRootDirCurTest().append(MANAGE_JSON); + SaveStringToFile(filePath, R"({"fileName" : "1.tar"})"); + UniqueFd fd(open(filePath.data(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)); + sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, move(fd)); + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_TRUE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_TRUE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); + EXPECT_TRUE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_TRUE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_OnBundleExtManageInfo_0100"; } @@ -562,14 +531,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0100 { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -596,19 +561,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0100 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0101"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); + EXPECT_TRUE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0101"; } @@ -624,20 +580,11 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0101 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0102, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0102"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); + EXPECT_TRUE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0102"; } @@ -653,20 +600,11 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0102 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0103, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0103"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); + EXPECT_FALSE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0103"; } @@ -682,45 +620,31 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0103 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtConnection_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtConnection_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - BackupExtInfo info; - info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME)); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; - auto ret = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_EQ(reinterpret_cast(ret.GetRefPtr()), - reinterpret_cast(info.backUpConnection.GetRefPtr())); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtConnection."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto temConnectPtr = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + auto backupExtConnPtr = temConnectPtr.promote(); + EXPECT_TRUE(backupExtConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + temConnectPtr = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + backupExtConnPtr = temConnectPtr.promote(); + EXPECT_TRUE(backupExtConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + temConnectPtr = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + backupExtConnPtr = temConnectPtr.promote(); + EXPECT_TRUE(backupExtConnPtr == nullptr); + + BackupExtInfo info; + info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME)); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; + auto ret = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + EXPECT_EQ(reinterpret_cast(ret.GetRefPtr()), + reinterpret_cast(info.backUpConnection.GetRefPtr())); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtConnection_0100"; } @@ -736,44 +660,30 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtConnection_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSAExtConnection_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetSAExtConnection_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - BackupExtInfo info; - info.saBackupConnection = make_shared(nullptr, nullptr, nullptr, nullptr); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; - auto ret = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME).lock(); - EXPECT_EQ(reinterpret_cast(ret.get()), reinterpret_cast(info.saBackupConnection.get())); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetSAExtConnection."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); + auto backupConnPtr = tempConnPtr.lock(); + EXPECT_TRUE(backupConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); + backupConnPtr = tempConnPtr.lock(); + EXPECT_TRUE(backupConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); + backupConnPtr = tempConnPtr.lock(); + EXPECT_TRUE(backupConnPtr == nullptr); + + BackupExtInfo info; + info.saBackupConnection = make_shared(nullptr, nullptr, nullptr, nullptr); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; + auto ret = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME).lock(); + EXPECT_EQ(reinterpret_cast(ret.get()), reinterpret_cast(info.saBackupConnection.get())); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetSAExtConnection_0100"; } @@ -912,37 +822,24 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0102 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0103, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0103"; - try { - string bundleName = ""; - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - auto action = sessionManagerPtr_->GetServiceSchedAction(bundleName); - EXPECT_EQ(action, BConstants::ServiceSchedAction::WAIT); - - sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); - action = sessionManagerPtr_->GetServiceSchedAction(bundleName); - EXPECT_NE(action, BConstants::ServiceSchedAction::START); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-SetServiceSchedAction Branches"; - sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::FINISH); - - try { - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetServiceSchedAction(bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction."; - } + string bundleName = ""; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + auto action = sessionManagerPtr_->GetServiceSchedAction(bundleName); + EXPECT_EQ(action, BConstants::ServiceSchedAction::UNKNOWN); + + sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); + action = sessionManagerPtr_->GetServiceSchedAction(bundleName); + EXPECT_NE(action, BConstants::ServiceSchedAction::START); + GTEST_LOG_(INFO) << "SvcSessionManagerTest-SetServiceSchedAction Branches"; + sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::FINISH); + + sessionManagerPtr_->impl_.clientToken = 0; + action = sessionManagerPtr_->GetServiceSchedAction(bundleName); + EXPECT_TRUE(action == BConstants::ServiceSchedAction::UNKNOWN); + + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); + EXPECT_TRUE(true); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0103"; } @@ -962,7 +859,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0100, tes EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->SetBackupExtName(BUNDLE_NAME, BUNDLE_NAME); string extName = sessionManagerPtr_->GetBackupExtName(BUNDLE_NAME); - EXPECT_EQ(extName, BUNDLE_NAME); + EXPECT_EQ(extName, ""); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtName."; @@ -982,32 +879,19 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtName_0101"; - try { - string bundleName = ""; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + string bundleName = ""; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); + EXPECT_TRUE(true); - try { - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBackupExtName(bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + sessionManagerPtr_->impl_.clientToken = 0; + auto backupExtName = sessionManagerPtr_->GetBackupExtName(bundleName); + EXPECT_EQ(backupExtName, ""); - sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); - string extName = sessionManagerPtr_->GetBackupExtName(bundleName); - EXPECT_NE(extName, bundleName); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtName."; - } + sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); + string extName = sessionManagerPtr_->GetBackupExtName(bundleName); + EXPECT_EQ(extName, ""); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtName_0101"; } @@ -1023,27 +907,18 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0101, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBackupExtInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBackupExtInfo_0100"; - try { - string bundleName = BUNDLE_NAME; - string extInfo = "test"; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = {}; - sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); - EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBackupExtInfo."; - } + string bundleName = BUNDLE_NAME; + string extInfo = "test"; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); + EXPECT_TRUE(true); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = {}; + sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); + EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBackupExtInfo_0100"; } @@ -1059,29 +934,20 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBackupExtInfo_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtInfo_0100"; - try { - string bundleName = BUNDLE_NAME; - string extInfo = "test"; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBackupExtInfo(bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - BackupExtInfo info; - info.extInfo = "test"; - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = info; - auto ret = sessionManagerPtr_->GetBackupExtInfo(bundleName); - EXPECT_EQ(ret, "test"); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtInfo."; - } + string bundleName = BUNDLE_NAME; + string extInfo = "test"; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto extInfoRet = sessionManagerPtr_->GetBackupExtInfo(bundleName); + EXPECT_EQ(extInfoRet, ""); + + BackupExtInfo info; + info.extInfo = "test"; + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = info; + auto ret = sessionManagerPtr_->GetBackupExtInfo(bundleName); + EXPECT_EQ(ret, "test"); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtInfo_0100"; } @@ -1099,14 +965,11 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_AppendBundles_0100, testin GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_AppendBundles_0100"; try { vector bundleNames; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->AppendBundles(bundleNames); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->AppendBundles(bundleNames); + EXPECT_TRUE(true); + bundleNames.clear(); bundleNames.emplace_back("app1"); @@ -1221,12 +1084,12 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleFileReady_0200, te EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->Deactive(nullptr, true); Init(IServiceReverse::Scenario::BACKUP); - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_FALSE(ret); + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); + EXPECT_FALSE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_FALSE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_FALSE(fileReady); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by OnBundleFileReady."; @@ -1342,25 +1205,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetOldBackupVersion_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleRestoreType_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleRestoreType_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); - EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].restoreType, RESTORE_DATA_READDY); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleRestoreType."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); + EXPECT_TRUE(true); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); + EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].restoreType, RESTORE_DATA_READDY); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleRestoreType_0100"; } @@ -1376,25 +1230,17 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleRestoreType_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleRestoreType_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleRestoreType_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleRestoreType."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); + EXPECT_TRUE(restoreType == RestoreTypeEnum::RESTORE_DATA_WAIT_SEND); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); + EXPECT_TRUE(restoreType == RestoreTypeEnum::RESTORE_DATA_WAIT_SEND); + EXPECT_TRUE(true); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleRestoreType_0100"; } @@ -1410,25 +1256,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleRestoreType_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionCode_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionCode_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); - EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].versionCode, 0); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleVersionCode."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); + EXPECT_TRUE(true); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); + EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].versionCode, 0); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleVersionCode_0100"; } @@ -1444,25 +1281,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionCode_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionCode_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionCode_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleVersionCode."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto versionCode = sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); + EXPECT_TRUE(versionCode == 0); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); + EXPECT_TRUE(true); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleVersionCode_0100"; } @@ -1479,14 +1307,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionName_0100, { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionName_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0"); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0"); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -1512,25 +1336,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionName_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionName_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionName_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleVersionName."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto versionStr = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); + EXPECT_EQ(versionStr, ""); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + versionStr = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); + EXPECT_EQ(versionStr, ""); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleVersionName_0100"; } @@ -1602,29 +1417,20 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Finish_0100, testing::ext: HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnAllBundlesFinished_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnAllBundlesFinished_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->IsOnAllBundlesFinished(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - sessionManagerPtr_->IsOnAllBundlesFinished(); - EXPECT_TRUE(true); - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - sessionManagerPtr_->IsOnAllBundlesFinished(); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by IsOnAllBundlesFinished."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + bool ret = sessionManagerPtr_->IsOnAllBundlesFinished(); + EXPECT_FALSE(ret); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + ret = sessionManagerPtr_->IsOnAllBundlesFinished(); + EXPECT_FALSE(ret); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + ret = sessionManagerPtr_->IsOnAllBundlesFinished(); + EXPECT_FALSE(ret); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_IsOnAllBundlesFinished_0100"; } @@ -1641,18 +1447,14 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnOnStartSched_0100, tes { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnOnStartSched_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->IsOnOnStartSched(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->IsOnOnStartSched(); + EXPECT_FALSE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.isBackupStart = false; - auto ret = sessionManagerPtr_->IsOnOnStartSched(); + ret = sessionManagerPtr_->IsOnOnStartSched(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.isBackupStart = true; @@ -1685,14 +1487,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleDataSize_0100, te { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleDataSize_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -1771,7 +1569,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_UpdateTimer_0100, testing: sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); - EXPECT_THROW(sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::TIMEOUT_INVALID, callback), BError); + EXPECT_FALSE(ret); BackupExtInfo info; info.extTimerStatus = false; @@ -1879,23 +1677,14 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_ClearSessionData_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIsIncrementalBackup_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIsIncrementalBackup_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetIsIncrementalBackup(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + bool ret = sessionManagerPtr_->GetIsIncrementalBackup(); + EXPECT_FALSE(ret); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->GetIsIncrementalBackup(); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetIsIncrementalBackup."; - } + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + ret = sessionManagerPtr_->GetIsIncrementalBackup(); + EXPECT_FALSE(ret); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIsIncrementalBackup_0100"; } @@ -1913,14 +1702,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIncrementalData_0100, t GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetIncrementalData_0100"; try { BIncrementalData incrementalData; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetIncrementalData(incrementalData); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetIncrementalData(incrementalData); + EXPECT_TRUE(true); incrementalData.bundleName = BUNDLE_NAME; sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; @@ -1947,25 +1732,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIncrementalData_0100, t HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIncrementalManifestFd_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIncrementalManifestFd_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetIncrementalManifestFd."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); + EXPECT_TRUE(ret == -1); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + ret = sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); + EXPECT_TRUE(ret == 0); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIncrementalManifestFd_0100"; } @@ -2065,14 +1841,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetClearDataFlag_0100, tes { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetClearDataFlag_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -2102,14 +1874,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetClearDataFlag_0100, tes { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetClearDataFlag_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME); + EXPECT_TRUE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -2139,14 +1907,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetPublishFlag_0100, testi { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetPublishFlag_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetPublishFlag(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetPublishFlag(BUNDLE_NAME); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); diff --git a/utils/include/b_resources/b_constants.h b/utils/include/b_resources/b_constants.h index 67d094749aa14eae07aab99833018de1d4f62778..4a0ad04e8094b65d1b77147ae4f57c55b9ae619e 100644 --- a/utils/include/b_resources/b_constants.h +++ b/utils/include/b_resources/b_constants.h @@ -45,6 +45,7 @@ enum ServiceSchedAction { RUNNING = 2, FINISH = 3, CLEAN = 4, + UNKNOWN = 5, }; constexpr int SPAN_USERID_UID = 200000;