[sm,launcher] Reimplement calculating start and stop instances

Current approach doesn't properly calculate instances that should be stopped and
started on run instances command. Reimplement this calculation by adding
'CalculateInstances' function. This function calculate instances that should be
stopped and started based on currently running instances and desired instances
received in run instances request. This function is implemented in the following
way:

* if desired instance ident not in current instances list, add this instance to
  start list;
* if desired instance ident is in current instances list, check if instance
  data, or service version are changed, or restart all instances is requested.
  In this case, add this item to start and stop lists;
* add all instances from current instances list that are not in desired list to
  stop list.

This commit also updates the unit test that check run instances API. Test data
is taken from golang sm implementation to make sure that it behaves in the same
way.

Signed-off-by: Oleksandr Grytsov <oleksandr_grytsov@epam.com>

Author: al1img

include/aos/sm/launcher.hpp

@@ -347,7 +347,7 @@ class Launcher : public LauncherItf,
     static constexpr auto cHostFSWhiteoutsDir = "whiteouts";
 
     static constexpr auto cAllocatorSize
-        = Max(sizeof(InstanceInfoStaticArray) + sizeof(InstanceDataStaticArray) * 2 + sizeof(ServiceInfoStaticArray)
+        = Max(sizeof(InstanceInfoStaticArray) + sizeof(InstanceDataStaticArray) * 3 + sizeof(ServiceInfoStaticArray)
                 + sizeof(LayerInfoStaticArray) + sizeof(servicemanager::ServiceDataStaticArray)
                 + sizeof(InstanceStatusStaticArray) + sizeof(servicemanager::ServiceData) + sizeof(InstanceData),
             sizeof(EnvVarsArray) + sizeof(InstanceStatusStaticArray) + sizeof(InstanceDataStaticArray));
@@ -365,9 +365,10 @@ class Launcher : public LauncherItf,
     void  StartInstances(const Array<InstanceData>& instances);
     void  RestartInstances(const Array<InstanceData>& instances);
     void  CacheServices(const Array<InstanceData>& instances);
-    Error GetStartInstances(const Array<InstanceInfo>& desiredInstances, Array<InstanceData>& startInstances) const;
-    Error GetStopInstances(
-        const Array<InstanceData>& startInstances, Array<InstanceData>& stopInstances, bool forceRestart) const;
+    Error GetDesiredInstancesData(
+        const Array<InstanceInfo>& desiredInstancesInfo, Array<InstanceData>& desiredInstancesData) const;
+    Error CalculateInstances(const Array<InstanceData>& desiredInstancesData, bool forceRestart,
+        Array<InstanceData>& startInstances, Array<InstanceData>& stopInstances);
     Error GetCurrentInstances(Array<InstanceData>& instances) const;
     Error StartInstance(const InstanceData& info);
     Error StopInstance(const String& instanceID);

src/sm/launcher/launcher.cpp

@@ -424,8 +424,8 @@ Error Launcher::ProcessLastInstances()
 
     auto stopInstances = MakeUnique<InstanceDataStaticArray>(&mAllocator);
 
-    if (auto err = GetStopInstances(*startInstances, *stopInstances, true); !err.IsNone()) {
-        LOG_WRN() << "Error occurred while getting stop instances: err=" << err;
+    if (auto err = GetCurrentInstances(*stopInstances); !err.IsNone()) {
+        LOG_WRN() << "Error occurred while getting current instances: err=" << err;
     }
 
     if (auto err = mLaunchPool.Run(); !err.IsNone()) {
@@ -442,19 +442,23 @@ Error Launcher::ProcessLastInstances()
     return ErrorEnum::eNone;
 }
 
-Error Launcher::ProcessInstances(const Array<InstanceInfo>& instances, const bool forceRestart)
+Error Launcher::ProcessInstances(const Array<InstanceInfo>& instances, bool forceRestart)
 {
     LOG_DBG() << "Process instances: restart=" << forceRestart;
 
-    auto startInstances = MakeUnique<InstanceDataStaticArray>(&mAllocator);
+    auto desiredInstances = MakeUnique<InstanceDataStaticArray>(&mAllocator);
 
-    if (auto err = GetStartInstances(instances, *startInstances); !err.IsNone()) {
+    if (auto err = GetDesiredInstancesData(instances, *desiredInstances); !err.IsNone()) {
         return err;
     }
 
-    auto stopInstances = MakeUnique<InstanceDataStaticArray>(&mAllocator);
+    auto startInstances = MakeUnique<InstanceDataStaticArray>(&mAllocator);
+    auto stopInstances  = MakeUnique<InstanceDataStaticArray>(&mAllocator);
+
+    CacheServices(*desiredInstances);
 
-    if (auto err = GetStopInstances(*startInstances, *stopInstances, forceRestart); !err.IsNone()) {
+    if (auto err = CalculateInstances(*desiredInstances, forceRestart, *startInstances, *stopInstances);
+        !err.IsNone()) {
         return err;
     }
 
@@ -463,7 +467,6 @@ Error Launcher::ProcessInstances(const Array<InstanceInfo>& instances, const boo
     }
 
     StopInstances(*stopInstances);
-    CacheServices(*startInstances);
     StartInstances(*startInstances);
 
     if (auto err = mLaunchPool.Shutdown(); !err.IsNone()) {
@@ -572,54 +575,50 @@ Error Launcher::SendOutdatedInstancesStatus(const Array<InstanceData>& instances
     return ErrorEnum::eNone;
 }
 
-Error Launcher::GetStartInstances(
-    const Array<InstanceInfo>& desiredInstances, Array<InstanceData>& runningInstances) const
+Error Launcher::GetDesiredInstancesData(
+    const Array<InstanceInfo>& desiredInstancesInfo, Array<InstanceData>& desiredInstancesData) const
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Get start instances";
+    LOG_DBG() << "Get desired instances data";
 
     auto currentInstances = MakeUnique<InstanceDataStaticArray>(&mAllocator);
 
     if (auto err = mStorage->GetAllInstances(*currentInstances); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
     }
 
-    for (const auto& desiredInstance : desiredInstances) {
-        auto currentInstance = currentInstances->FindIf([&desiredInstance](const InstanceData& instance) {
-            return instance.mInstanceInfo.mInstanceIdent == desiredInstance.mInstanceIdent;
+    for (const auto& instanceInfo : desiredInstancesInfo) {
+        auto currentInstance = currentInstances->FindIf([&instanceInfo](const InstanceData& instance) {
+            return instance.mInstanceInfo.mInstanceIdent == instanceInfo.mInstanceIdent;
         });
+        if (currentInstance == currentInstances->end()) {
+            const auto instanceID = uuid::UUIDToString(uuid::CreateUUID());
 
-        if (currentInstance != currentInstances->end() && currentInstance) {
-            // Update instance if parameters are changed
-            if (currentInstance->mInstanceInfo != desiredInstance) {
-                if (auto err = runningInstances.PushBack(*currentInstance); !err.IsNone()) {
-                    return AOS_ERROR_WRAP(err);
-                }
-
-                auto& updateInstance = runningInstances.Back();
-
-                updateInstance.mInstanceInfo = desiredInstance;
-
-                if (auto err = mStorage->UpdateInstance(updateInstance); !err.IsNone()) {
-                    LOG_ERR() << "Can't update instance: instanceID=" << updateInstance.mInstanceID << ", err=" << err;
-                }
+            if (auto err = desiredInstancesData.EmplaceBack(instanceInfo, instanceID); !err.IsNone()) {
+                return AOS_ERROR_WRAP(err);
             }
 
-            currentInstances->Erase(currentInstance);
+            if (auto err = mStorage->AddInstance(desiredInstancesData.Back()); !err.IsNone()) {
+                LOG_ERR() << "Can't add instance: instanceID=" << instanceID << ", err=" << err;
+            }
 
             continue;
         }
 
-        const auto instanceID = uuid::UUIDToString(uuid::CreateUUID());
-
-        if (auto err = runningInstances.EmplaceBack(desiredInstance, instanceID); !err.IsNone()) {
+        if (auto err = desiredInstancesData.EmplaceBack(instanceInfo, currentInstance->mInstanceID); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
 
-        if (auto err = mStorage->AddInstance(runningInstances.Back()); !err.IsNone()) {
-            LOG_ERR() << "Can't add instance: instanceID=" << instanceID << ", err=" << err;
+        // Update instance if parameters are changed
+        if (currentInstance->mInstanceInfo != instanceInfo) {
+            if (auto err = mStorage->UpdateInstance(desiredInstancesData.Back()); !err.IsNone()) {
+                LOG_ERR() << "Can't update instance: instanceID=" << desiredInstancesData.Back().mInstanceID
+                          << ", err=" << err;
+            }
         }
+
+        currentInstances->Erase(currentInstance);
     }
 
     // Remove old instances
@@ -630,48 +629,63 @@ Error Launcher::GetStartInstances(
         }
     }
 
+    // Sort by priority
+
+    auto tmpValue = MakeUnique<InstanceData>(&mAllocator);
+
+    desiredInstancesData.Sort(
+        [](const InstanceData& instance1, const InstanceData& instance2) {
+            return instance1.mInstanceInfo.mPriority > instance2.mInstanceInfo.mPriority;
+        },
+        *tmpValue);
+
     return ErrorEnum::eNone;
 }
 
-Error Launcher::GetStopInstances(
-    const Array<InstanceData>& startInstances, Array<InstanceData>& stopInstances, bool forceRestart) const
+Error Launcher::CalculateInstances(const Array<InstanceData>& desiredInstancesData, bool forceRestart,
+    Array<InstanceData>& startInstances, Array<InstanceData>& stopInstances)
 {
-    LockGuard lock {mMutex};
-
-    LOG_DBG() << "Get stop instances";
-
-    UniquePtr<servicemanager::ServiceDataStaticArray> services;
+    for (const auto& desiredInstance : desiredInstancesData) {
+        auto currentInstance = mCurrentInstances.FindIf([&desiredInstance](const Instance& instance) {
+            return instance.Info().mInstanceIdent == desiredInstance.mInstanceInfo.mInstanceIdent;
+        });
 
-    if (!forceRestart) {
-        services = MakeUnique<servicemanager::ServiceDataStaticArray>(&mAllocator);
+        if (currentInstance == mCurrentInstances.end()) {
+            if (auto err = startInstances.EmplaceBack(desiredInstance); !err.IsNone()) {
+                return AOS_ERROR_WRAP(err);
+            }
 
-        if (auto err = mServiceManager->GetAllServices(*services); !err.IsNone()) {
-            return AOS_ERROR_WRAP(err);
+            continue;
         }
-    }
 
-    for (const auto& instance : mCurrentInstances) {
-        auto found = startInstances.FindIf([this, &instance = instance](const InstanceData& info) {
-            auto compareInfo = MakeUnique<InstanceData>(&mAllocator, info);
+        auto compareInfo = MakeUnique<InstanceInfo>(&mAllocator, currentInstance->Info());
 
-            compareInfo->mInstanceInfo.mPriority = instance.Info().mPriority;
+        compareInfo->mPriority = desiredInstance.mInstanceInfo.mPriority;
 
-            return compareInfo->mInstanceID == instance.InstanceID() && compareInfo->mInstanceInfo == instance.Info();
-        }) != startInstances.end();
+        auto service = GetService(desiredInstance.mInstanceInfo.mInstanceIdent.mServiceID);
 
-        // Stop instance if: forceRestart or not in instances array or not active state or Aos version changed
-        if (!forceRestart && found && instance.RunState() == InstanceRunStateEnum::eActive) {
-            auto findService = services->FindIf([&instance = instance](const servicemanager::ServiceData& service) {
-                return instance.Info().mInstanceIdent.mServiceID == service.mServiceID;
-            });
+        if ((*compareInfo != desiredInstance.mInstanceInfo) || service == mCurrentServices.end()
+            || service->mVersion != currentInstance->GetServiceVersion() || forceRestart) {
+            if (auto err = stopInstances.EmplaceBack(currentInstance->Info(), currentInstance->InstanceID());
+                !err.IsNone()) {
+                return AOS_ERROR_WRAP(err);
+            }
 
-            if (findService != services->end() && instance.GetServiceVersion() == findService->mVersion) {
-                continue;
+            if (auto err = startInstances.EmplaceBack(desiredInstance); !err.IsNone()) {
+                return AOS_ERROR_WRAP(err);
             }
         }
+    }
 
-        if (auto err = stopInstances.EmplaceBack(instance.Info(), instance.InstanceID()); !err.IsNone()) {
-            return AOS_ERROR_WRAP(err);
+    for (const auto& currentInstance : mCurrentInstances) {
+        if (desiredInstancesData.FindIf([&currentInstance](const InstanceData& instance) {
+                return instance.mInstanceInfo.mInstanceIdent == currentInstance.Info().mInstanceIdent;
+            })
+            == desiredInstancesData.end()) {
+            if (auto err = stopInstances.EmplaceBack(currentInstance.Info(), currentInstance.InstanceID());
+                !err.IsNone()) {
+                return AOS_ERROR_WRAP(err);
+            }
         }
     }