From cc6a3caea907b6bb2fe7bde698520441cdb20feb Mon Sep 17 00:00:00 2001 From: Oleksandr Grytsov Date: Wed, 11 Feb 2026 14:19:36 +0200 Subject: [PATCH] sm: launcher: redesign cached instance data handling * make StartInstance and StopInstance add task to thread pool; * add instance to cache in StartInstance; * remove instance from cache in StopInstance; * send node status based on cached instances: if instance successfully stopped, it is not present in the node status. Signed-off-by: Oleksandr Grytsov Reviewed-by: Mykola Kobets Reviewed-by: Mykola Solianko Reviewed-by: Mykhailo Lohvynenko --- src/core/sm/launcher/launcher.cpp | 361 +++++++++++++----------- src/core/sm/launcher/launcher.hpp | 18 +- src/core/sm/launcher/tests/launcher.cpp | 13 +- 3 files changed, 204 insertions(+), 188 deletions(-) diff --git a/src/core/sm/launcher/launcher.cpp b/src/core/sm/launcher/launcher.cpp index 377c52eb5..d958f2352 100644 --- a/src/core/sm/launcher/launcher.cpp +++ b/src/core/sm/launcher/launcher.cpp @@ -59,15 +59,15 @@ Error Launcher::Start() << Log::Field("type", runtimeInfo.mRuntimeType); } - auto storedInstances = MakeUnique(&mAllocator); + mIsRunning = true; - if (auto err = mStorage->GetAllInstancesInfos(*storedInstances); !err.IsNone()) { + if (auto err = mRebootThread.Run([this](void*) { RunRebootThread(); }); !err.IsNone()) { return AOS_ERROR_WRAP(err); } - mIsRunning = true; + auto storedInstances = MakeUnique(&mAllocator); - if (auto err = mRebootThread.Run([this](void*) { RunRebootThread(); }); !err.IsNone()) { + if (auto err = mStorage->GetAllInstancesInfos(*storedInstances); !err.IsNone()) { return AOS_ERROR_WRAP(err); } @@ -147,9 +147,9 @@ Error Launcher::OnInstancesStatusesReceived(const Array& statuse LOG_DBG() << "Instances statuses received" << Log::Field("count", statuses.Size()); for (const auto& status : statuses) { - LOG_INF() << "Instance status received" << Log::Field("ident", static_cast(status)) + LOG_INF() << "Instance status received" << Log::Field("instance", status) << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("state", status.mState) - << Log::Field("error", status.mError); + << Log::Field(status.mError); if (auto storeErr = StoreInstalledComponent(status); err.IsNone() && !storeErr.IsNone()) { err = AOS_ERROR_WRAP(storeErr); @@ -242,9 +242,9 @@ Error Launcher::GetInstanceMonitoringParams(const InstanceIdent& instanceIdent, { LockGuard lock {mMutex}; - LOG_DBG() << "Get instance monitoring params" << Log::Field("ident", instanceIdent); + LOG_DBG() << "Get instance monitoring params" << Log::Field("instance", instanceIdent); - const auto instanceData = FindInstanceData(instanceIdent); + const auto* const instanceData = FindInstanceData(instanceIdent); if (!instanceData) { return AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "instance not found")); } @@ -264,8 +264,8 @@ Error Launcher::GetInstanceMonitoringData( LockGuard lock {mMutex}; const auto* const instanceData = FindInstanceData(instanceIdent); - if (instanceData == nullptr) { - return AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "Instance not found")); + if (!instanceData) { + return AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "instance not found")); } if (auto* runtime = FindInstanceRuntime(instanceData->mStatus.mRuntimeID); runtime != nullptr) { @@ -357,7 +357,7 @@ Error Launcher::StoreInstalledComponent(const aos::InstanceStatus& status) auto instanceInfo = MakeUnique(&mAllocator); - static_cast(*instanceInfo) = static_cast(status); + static_cast(*instanceInfo) = status; instanceInfo->mRuntimeID = status.mRuntimeID; instanceInfo->mType = status.mType; instanceInfo->mVersion = status.mVersion; @@ -375,16 +375,23 @@ void Launcher::UpdateInstancesImpl(Array& stopInstances, const Ar LOG_INF() << "Update instances" << Log::Field("stopCount", stopInstances.Size()) << Log::Field("startCount", startInstances.Size()); - auto statuses = MakeUnique(&mAllocator); + auto sendStatus = DeferRelease(&mInstances, [this](Array* instances) { + LockGuard lock {mMutex}; - auto sendStatus = DeferRelease(statuses.Get(), [this](const InstanceStatusArray* statuses) { if (!mFirstStart) { - LOG_INF() << "Send node instances statuses" << Log::Field("count", statuses->Size()); + LOG_INF() << "Send node instances statuses" << Log::Field("count", instances->Size()); + + auto statuses = MakeUnique(&mAllocator); - for (const auto& status : *statuses) { - LOG_INF() << "Node instance status" << Log::Field("ident", static_cast(status)) - << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("state", status.mState) - << Log::Field("error", status.mError); + for (const auto& instance : *instances) { + LOG_INF() << "Node instance status" << Log::Field("instance", instance.mInfo) + << Log::Field("runtimeID", instance.mInfo.mRuntimeID) + << Log::Field("state", instance.mStatus.mState) << Log::Field(instance.mStatus.mError); + + if (auto err = statuses->EmplaceBack(instance.mStatus); !err.IsNone()) { + LOG_ERR() << "Failed to add instance status to list" << Log::Field("instance", instance.mInfo) + << Log::Field(AOS_ERROR_WRAP(err)); + } } if (auto err = mSender->SendNodeInstancesStatuses(*statuses); !err.IsNone()) { @@ -394,8 +401,6 @@ void Launcher::UpdateInstancesImpl(Array& stopInstances, const Ar return; } - LockGuard lock {mMutex}; - mFirstStart = false; }); @@ -409,23 +414,22 @@ void Launcher::UpdateInstancesImpl(Array& stopInstances, const Ar LOG_ERR() << "Failed to append instances with modified params to stop list" << Log::Field(AOS_ERROR_WRAP(err)); } - StopInstances(stopInstances, *statuses); + auto removeItems = MakeUnique>(&mAllocator); - if (auto err = mLaunchPool.Wait(); !err.IsNone()) { - LOG_ERR() << "Thread pool wait failed" << Log::Field(AOS_ERROR_WRAP(err)); + if (!mFirstStart) { + GetRemoveUpdateItems(stopInstances, startInstances, *removeItems); } - if (!mFirstStart) { - RemoveUpdateItems(stopInstances, startInstances); + StopInstances(stopInstances); - if (auto err = mLaunchPool.Wait(); !err.IsNone()) { - LOG_ERR() << "Thread pool wait failed" << Log::Field(AOS_ERROR_WRAP(err)); - } + if (auto err = mLaunchPool.Wait(); !err.IsNone()) { + LOG_ERR() << "Thread pool wait failed" << Log::Field(AOS_ERROR_WRAP(err)); } - ClearCachedInstances(); + RemoveInstancesData(stopInstances); if (!mFirstStart) { + RemoveUpdateItems(*removeItems); InstallUpdateItems(startInstances); if (auto err = mLaunchPool.Wait(); !err.IsNone()) { @@ -442,62 +446,51 @@ void Launcher::UpdateInstancesImpl(Array& stopInstances, const Ar if (auto err = mLaunchPool.Shutdown(); !err.IsNone()) { LOG_ERR() << "Thread pool shutdown failed" << Log::Field(AOS_ERROR_WRAP(err)); } - - PopulateInstancesStatuses(*statuses); } -void Launcher::StopInstances(const Array& stopInstances, Array& statuses) +void Launcher::StopInstances(const Array& stopInstances) { for (const auto& instance : stopInstances) { - if (auto err = statuses.EmplaceBack(); !err.IsNone()) { - LOG_ERR() << "Stop instance failed" << Log::Field("ident", instance) << Log::Field(AOS_ERROR_WRAP(err)); + auto instanceData = FindInstanceData(instance); + if (!instanceData) { + LOG_ERR() << "Failed to stop instance" << Log::Field("instance", instance) + << Log::Field(AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "instance not found"))); continue; } - StopInstance(instance, statuses.Back()); + if (auto err = StopInstance(*instanceData); !err.IsNone()) { + LOG_ERR() << "Failed to stop instance" << Log::Field("instance", instance) << Log::Field(err); + + SetInstanceState(*instanceData, InstanceStateEnum::eFailed, AOS_ERROR_WRAP(err)); + } } } -void Launcher::StopInstance(const InstanceIdent& instanceIdent, InstanceStatus& status) +Error Launcher::StopInstance(InstanceData& instanceData) { - static_cast(status) = instanceIdent; - - auto itInstance = FindInstanceData(instanceIdent); - if (itInstance == mInstances.end()) { - status.mState = InstanceStateEnum::eFailed; - status.mError = AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "instance not found")); - - return; - } - - status = itInstance->mStatus; - - auto runtime = FindInstanceRuntime(itInstance->mStatus.mRuntimeID); + auto runtime = FindInstanceRuntime(instanceData.mStatus.mRuntimeID); if (runtime == nullptr) { - status.mState = InstanceStateEnum::eFailed; - status.mError = AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "runtime not found")); - - return; + return AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "runtime not found")); } - if (auto errAddTask = mLaunchPool.AddTask([this, runtime, &instanceIdent, status = &status](void*) { - LOG_INF() << "Stop instance" << Log::Field("ident", instanceIdent); + if (auto err = mLaunchPool.AddTask([this, runtime, &instanceData](void*) { + LOG_INF() << "Stop instance" << Log::Field("instance", instanceData.mInfo) + << Log::Field("version", instanceData.mInfo.mVersion) + << Log::Field("runtimeID", instanceData.mInfo.mRuntimeID); - if (auto err = runtime->StopInstance(instanceIdent, *status); !err.IsNone()) { - LOG_ERR() << "Failed to stop instance" << Log::Field("ident", instanceIdent) + if (auto err = runtime->StopInstance(instanceData.mInfo, instanceData.mStatus); !err.IsNone()) { + LOG_ERR() << "Failed to stop instance" << Log::Field("instance", instanceData.mInfo) << Log::Field(AOS_ERROR_WRAP(err)); - if (status->mState != InstanceStateEnum::eFailed) { - status->mState = InstanceStateEnum::eFailed; - status->mError = AOS_ERROR_WRAP(err); - } + return; } }); - !errAddTask.IsNone()) { - LOG_ERR() << "Stop instance failed" << Log::Field("ident", instanceIdent) - << Log::Field(AOS_ERROR_WRAP(errAddTask)); + !err.IsNone()) { + return AOS_ERROR_WRAP(err); } + + return ErrorEnum::eNone; } void Launcher::StopAllInstances() @@ -514,7 +507,11 @@ void Launcher::StopAllInstances() continue; } - StopInstance(static_cast(instance.mInfo), instance.mStatus); + if (auto err = StopInstance(instance); !err.IsNone()) { + LOG_ERR() << "Failed to stop instance" << Log::Field("instance", instance.mInfo) << Log::Field(err); + + SetInstanceState(instance, InstanceStateEnum::eFailed, AOS_ERROR_WRAP(err)); + } } if (auto err = mLaunchPool.Wait(); !err.IsNone()) { @@ -529,90 +526,77 @@ void Launcher::StopAllInstances() void Launcher::StartInstances(const Array& startInstances) { for (const auto& instance : startInstances) { - if (auto err = mInstances.EmplaceBack(); !err.IsNone()) { - LOG_ERR() << "Start instance failed" << Log::Field("instance", static_cast(instance)) - << Log::Field(AOS_ERROR_WRAP(err)); - } - - mInstances.Back().mInfo = instance; - static_cast(mInstances.Back().mStatus) = static_cast(instance); - mInstances.Back().mStatus.mVersion = instance.mVersion; - mInstances.Back().mStatus.mRuntimeID = instance.mRuntimeID; - mInstances.Back().mStatus.mState = InstanceStateEnum::eInactive; - } + auto instanceData = FindInstanceData(instance); + if (!instanceData) { + Error err; - for (auto& instance : mInstances) { - auto runtime = FindInstanceRuntime(instance.mInfo.mRuntimeID); - if (runtime == nullptr) { - instance.mStatus.mState = InstanceStateEnum::eFailed; - instance.mStatus.mError = AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "Runtime not found")); + Tie(instanceData, err) = AddInstanceData(instance); + if (!err.IsNone()) { + LOG_ERR() << "Failed to add instance data" << Log::Field("instance", instance) + << Log::Field(AOS_ERROR_WRAP(err)); - continue; + continue; + } } - if (auto err = mLaunchPool.AddTask([this, runtime, &instance](void*) { StartInstance(*runtime, instance); }); - !err.IsNone()) { - LOG_ERR() << "Start instance failed" - << Log::Field("instance", static_cast(instance.mInfo)) + if (auto err = StartInstance(*instanceData); !err.IsNone()) { + LOG_ERR() << "Failed to start instance" << Log::Field("instance", instance) << Log::Field(AOS_ERROR_WRAP(err)); - continue; + SetInstanceState(*instanceData, InstanceStateEnum::eFailed, AOS_ERROR_WRAP(err)); } } } -void Launcher::StartInstance(RuntimeItf& runtime, InstanceData& instance) +Error Launcher::StartInstance(InstanceData& instanceData) { - LOG_INF() << "Start instance" << Log::Field("instance", static_cast(instance.mInfo)) - << Log::Field("version", instance.mInfo.mVersion) << Log::Field("runtimeID", instance.mInfo.mRuntimeID) - << Log::Field("manifestDigest", instance.mInfo.mManifestDigest); + SetInstanceState(instanceData, InstanceStateEnum::eActivating); - instance.mStatus.mState = InstanceStateEnum::eActivating; + auto runtime = FindInstanceRuntime(instanceData.mInfo.mRuntimeID); + if (runtime == nullptr) { + return AOS_ERROR_WRAP(Error(ErrorEnum::eNotFound, "runtime not found")); + } - if (auto err = runtime.StartInstance(instance.mInfo, instance.mStatus); !err.IsNone()) { - LOG_ERR() << "Start instance failed" - << Log::Field("instance", static_cast(instance.mInfo)) << Log::Field(err); + if (auto err = mLaunchPool.AddTask([this, runtime, &instanceData](void*) { + LOG_INF() << "Start instance" << Log::Field("instance", instanceData.mInfo) + << Log::Field("version", instanceData.mInfo.mVersion) + << Log::Field("runtimeID", instanceData.mInfo.mRuntimeID) + << Log::Field("manifestDigest", instanceData.mInfo.mManifestDigest); - if (instance.mStatus.mState != InstanceStateEnum::eFailed) { - instance.mStatus.mState = InstanceStateEnum::eFailed; - instance.mStatus.mError = AOS_ERROR_WRAP(err); - } + if (auto err = runtime->StartInstance(instanceData.mInfo, instanceData.mStatus); !err.IsNone()) { + LOG_ERR() << "Failed to start instance" << Log::Field("instance", instanceData.mInfo) + << Log::Field(AOS_ERROR_WRAP(err)); - return; + return; + } + }); + !err.IsNone()) { + return AOS_ERROR_WRAP(err); } - if (auto err = mStorage->UpdateInstanceInfo(instance.mInfo); !err.IsNone()) { - LOG_ERR() << "Start instance failed" - << Log::Field("instance", static_cast(instance.mInfo)) << Log::Field(err); - - if (instance.mStatus.mState != InstanceStateEnum::eFailed) { - instance.mStatus.mState = InstanceStateEnum::eFailed; - instance.mStatus.mError = AOS_ERROR_WRAP(err); - } - } + return ErrorEnum::eNone; } Error Launcher::AppendInstancesWithModifiedParams( const Array& startInstances, Array& stopInstances) { for (const auto& startInstance : startInstances) { - auto itInstance = FindInstanceData(static_cast(startInstance)); - if (!itInstance) { + const auto* const instanceData = FindInstanceData(startInstance); + if (!instanceData) { continue; } - if (itInstance->mInfo == startInstance) { + if (instanceData->mInfo == startInstance) { continue; } - if (stopInstances.Contains(static_cast(startInstance))) { + if (stopInstances.Contains(startInstance)) { continue; } - LOG_DBG() << "Instance parameters modified, adding to stop list" - << Log::Field("ident", static_cast(startInstance)); + LOG_DBG() << "Instance parameters modified, adding to stop list" << Log::Field("instance", startInstance); - if (auto err = stopInstances.EmplaceBack(static_cast(startInstance)); !err.IsNone()) { + if (auto err = stopInstances.EmplaceBack(startInstance); !err.IsNone()) { return AOS_ERROR_WRAP(err); } } @@ -620,47 +604,6 @@ Error Launcher::AppendInstancesWithModifiedParams( return ErrorEnum::eNone; } -void Launcher::PopulateInstancesStatuses(Array& statuses) const -{ - for (const auto& status : mInstances) { - if (auto itStatus = statuses.FindIf([&status](const auto& item) { - return static_cast(item) == static_cast(status.mStatus) - && item.mVersion == status.mStatus.mVersion; - }); - itStatus != statuses.end()) { - statuses.Erase(itStatus); - } - - if (auto err = statuses.EmplaceBack(status.mStatus); !err.IsNone()) { - LOG_ERR() << "Failed to add instance status to statuses array" - << Log::Field("ident", static_cast(status.mStatus)) - << Log::Field(AOS_ERROR_WRAP(err)); - } - } -} - -void Launcher::ClearCachedInstances() -{ - LockGuard lock {mMutex}; - - const auto removedCount = mInstances.RemoveIf([this](const auto& instance) { - if (IsPreinstalledInstance(instance.mStatus)) { - return false; - } - - if (auto err = mStorage->RemoveInstanceInfo(static_cast(mInstances.Back().mInfo)); - !err.IsNone() && !err.Is(ErrorEnum::eNotFound)) { - LOG_ERR() << "Remove instance info failed" - << Log::Field("ident", static_cast(mInstances.Back().mInfo)) - << Log::Field(AOS_ERROR_WRAP(err)); - } - - return true; - }); - - LOG_DBG() << "Removed instances count" << Log::Field("count", removedCount); -} - Error Launcher::StartLaunch() { LockGuard lock {mMutex}; @@ -682,11 +625,6 @@ void Launcher::FinishLaunch() mCondVar.NotifyAll(); } -bool Launcher::IsPreinstalledInstance(const InstanceStatus& status) const -{ - return status.mPreinstalled; -} - Launcher::InstanceData* Launcher::FindInstanceData(const InstanceIdent& instanceIdent) { auto it = mInstances.FindIf([&instanceIdent](const auto& instance) { @@ -723,7 +661,7 @@ RuntimeItf* Launcher::FindInstanceRuntime(const String& runtimeID) const RuntimeItf* Launcher::FindInstanceRuntime(const InstanceIdent& instanceIdent) { const auto* const instanceData = FindInstanceData(instanceIdent); - if (instanceData == nullptr) { + if (!instanceData) { return nullptr; } @@ -735,12 +673,11 @@ RuntimeItf* Launcher::FindInstanceRuntime(const InstanceIdent& instanceIdent) co return const_cast(this)->FindInstanceRuntime(instanceIdent); } -void Launcher::RemoveUpdateItems(const Array& stopInstances, const Array& startInstances) +void Launcher::GetRemoveUpdateItems(const Array& stopInstances, + const Array& startInstances, Array& removeItems) { - auto removeItems = MakeUnique>(&mAllocator); - for (const auto& instanceIdent : stopInstances) { - auto instanceData = FindInstanceData(instanceIdent); + const auto* const instanceData = FindInstanceData(instanceIdent); if (!instanceData) { LOG_ERR() << "Instance not found, skip removing update item" << Log::Field("instance", instanceIdent); @@ -754,15 +691,18 @@ void Launcher::RemoveUpdateItems(const Array& stopInstances, cons continue; } - if (auto it = removeItems->FindIf([&instanceData](const auto& item) { + if (auto it = removeItems.FindIf([&instanceData](const auto& item) { return item.mItemID == instanceData->mInfo.mItemID && item.mVersion == instanceData->mInfo.mVersion; }); - it == removeItems->end()) { - removeItems->EmplaceBack(UpdateItemInfo {instanceData->mInfo.mItemID, instanceData->mInfo.mVersion}); + it == removeItems.end()) { + removeItems.EmplaceBack(UpdateItemInfo {instanceData->mInfo.mItemID, instanceData->mInfo.mVersion}); } } +} - for (const auto& updateItem : *removeItems) { +void Launcher::RemoveUpdateItems(const Array& removeItems) +{ + for (const auto& updateItem : removeItems) { if (auto err = mLaunchPool.AddTask([this, &updateItem](void*) { if (auto err = mImageManager->RemoveUpdateItem(updateItem.mItemID, updateItem.mVersion); !err.IsNone() && !err.Is(ErrorEnum::eNotFound)) { @@ -821,4 +761,83 @@ void Launcher::InstallUpdateItems(const Array& startInstances) } } +RetWithError Launcher::AddInstanceData(const InstanceInfo& instanceInfo) +{ + LockGuard lock {mMutex}; + + LOG_DBG() << "Add instance data" << Log::Field("instance", instanceInfo) + << Log::Field("runtimeID", instanceInfo.mRuntimeID); + + if (auto err = mStorage->UpdateInstanceInfo(instanceInfo); !err.IsNone()) { + LOG_ERR() << "Failed to update instance info in storage" << Log::Field("instance", instanceInfo) + << Log::Field(AOS_ERROR_WRAP(err)); + } + + if (auto err = mInstances.EmplaceBack(); !err.IsNone()) { + return {nullptr, AOS_ERROR_WRAP(err)}; + } + + auto itInstance = &mInstances.Back(); + + itInstance->mInfo = instanceInfo; + static_cast(itInstance->mStatus) = instanceInfo; + itInstance->mStatus.mVersion = instanceInfo.mVersion; + itInstance->mStatus.mRuntimeID = instanceInfo.mRuntimeID; + itInstance->mStatus.mState = InstanceStateEnum::eInactive; + + return itInstance; +} + +Error Launcher::RemoveInstanceData(const InstanceIdent& instanceIdent) +{ + LockGuard lock {mMutex}; + + LOG_DBG() << "Remove instance data" << Log::Field("instance", instanceIdent); + if (auto err = mStorage->RemoveInstanceInfo(instanceIdent); !err.IsNone()) { + LOG_ERR() << "Remove instance info from storage failed" << Log::Field("instance", instanceIdent) + << Log::Field(AOS_ERROR_WRAP(err)); + } + + if (auto count = mInstances.RemoveIf([this, &instanceIdent](const auto& instanceData) { + return static_cast(instanceData.mInfo) == instanceIdent; + }); + count == 0) { + return AOS_ERROR_WRAP(ErrorEnum::eNotFound); + } + + return ErrorEnum::eNone; +} + +void Launcher::RemoveInstancesData(const Array& instances) +{ + for (const auto& instanceIdent : instances) { + auto instanceData = FindInstanceData(instanceIdent); + if (!instanceData) { + LOG_ERR() << "Instance data not found, skip removing" << Log::Field("instance", instanceIdent); + } else if (instanceData->mStatus.mState != InstanceStateEnum::eInactive) { + LOG_ERR() << "Instance is not inactive, skip removing" << Log::Field("instance", instanceIdent) + << Log::Field("state", instanceData->mStatus.mState); + + continue; + } + + if (auto err = RemoveInstanceData(instanceIdent); !err.IsNone()) { + LOG_ERR() << "Failed to remove instance data" << Log::Field("instance", instanceIdent) + << Log::Field(AOS_ERROR_WRAP(err)); + } + } +} + +void Launcher::SetInstanceState(InstanceData& instance, const InstanceState& state, const Error& error) +{ + LockGuard lock {mMutex}; + + if (instance.mStatus.mState == state) { + return; + } + + instance.mStatus.mState = state; + instance.mStatus.mError = error; +} + } // namespace aos::sm::launcher diff --git a/src/core/sm/launcher/launcher.hpp b/src/core/sm/launcher/launcher.hpp index 1ae3bfc31..98b8571b7 100644 --- a/src/core/sm/launcher/launcher.hpp +++ b/src/core/sm/launcher/launcher.hpp @@ -162,21 +162,25 @@ class Launcher : public LauncherItf, void RunRebootThread(); Error StoreInstalledComponent(const aos::InstanceStatus& status); void UpdateInstancesImpl(Array& stopInstances, const Array& startInstances); - void StopInstances(const Array& stopInstances, Array& statuses); - void StopInstance(const InstanceIdent& instanceIdent, InstanceStatus& status); + void StopInstances(const Array& stopInstances); + Error StopInstance(InstanceData& instanceData); void StopAllInstances(); void StartInstances(const Array& startInstances); - void StartInstance(RuntimeItf& runtime, InstanceData& instance); + Error StartInstance(InstanceData& instanceData); Error AppendInstancesWithModifiedParams( const Array& startInstances, Array& stopInstances); - void PopulateInstancesStatuses(Array& statuses) const; - void ClearCachedInstances(); Error StartStoredInstances(); Error StartLaunch(); void FinishLaunch(); - bool IsPreinstalledInstance(const InstanceStatus& status) const; - void RemoveUpdateItems(const Array& stopInstances, const Array& startInstances); + bool IsPreinstalledInstance(const InstanceStatus& status) const { return status.mPreinstalled; } + void GetRemoveUpdateItems(const Array& stopInstances, const Array& startInstances, + Array& removeItems); + void RemoveUpdateItems(const Array& removeItems); void InstallUpdateItems(const Array& startInstances); + RetWithError AddInstanceData(const InstanceInfo& instanceInfo); + Error RemoveInstanceData(const InstanceIdent& instanceIdent); + void RemoveInstancesData(const Array& instances); + void SetInstanceState(InstanceData& instance, const InstanceState& state, const Error& error = ErrorEnum::eNone); InstanceData* FindInstanceData(const InstanceIdent& instanceIdent); InstanceData* FindInstanceData(const InstanceIdent& instanceIdent) const; diff --git a/src/core/sm/launcher/tests/launcher.cpp b/src/core/sm/launcher/tests/launcher.cpp index 2d28227d5..3a6885624 100644 --- a/src/core/sm/launcher/tests/launcher.cpp +++ b/src/core/sm/launcher/tests/launcher.cpp @@ -425,17 +425,10 @@ TEST_F(LauncherTest, UpdateInstances) err = mSender.WaitStatuses(mReceivedStatuses, cWaitTimeout); ASSERT_TRUE(err.IsNone()) << tests::utils::ErrorToStr(err); - ASSERT_EQ(mReceivedStatuses.Size(), cStopInstances.Size() + cStartInstances.Size()); + ASSERT_EQ(mReceivedStatuses.Size(), cStartInstances.Size()); - size_t i = 0; - for (size_t j = 0; j < cStopInstances.Size(); ++j, ++i) { - EXPECT_EQ(mReceivedStatuses[i], - CreateInstanceStatus( - cStopInstances[j], cStoredInfos[j].mVersion, cStoredInfos[j].mRuntimeID, InstanceStateEnum::eInactive)); - } - - for (size_t j = 0; j < cStartInstances.Size(); ++j, ++i) { - EXPECT_EQ(mReceivedStatuses[i], CreateInstanceStatus(cStartInstances[j], InstanceStateEnum::eActive)); + for (size_t i = 0; i < cStartInstances.Size(); ++i) { + EXPECT_EQ(mReceivedStatuses[i], CreateInstanceStatus(cStartInstances[i], InstanceStateEnum::eActive)); } auto storedData = std::make_unique();