Refactor network manager

src/core/cm/CMakeLists.txt

@@ -22,7 +22,6 @@ set(INSTALL_HEADERS
     aos_core_cm_fileserver
     aos_core_cm_iamclient
     aos_core_cm_imagemanager
-    aos_core_cm_networkmanager
     aos_core_cm_nodeinfoprovider
     aos_core_cm_smcontroller
     aos_core_cm_storagestate
@@ -60,7 +59,6 @@ add_subdirectory(iamclient)
 add_subdirectory(imagemanager)
 add_subdirectory(launcher)
 add_subdirectory(monitoring)
-add_subdirectory(networkmanager)
 add_subdirectory(nodeinfoprovider)
 add_subdirectory(smcontroller)
 add_subdirectory(storagestate)

src/core/cm/launcher/CMakeLists.txt

@@ -21,7 +21,6 @@ set(SOURCES
     instance.cpp
     instancemanager.cpp
     launcher.cpp
-    networkmanager.cpp
     node.cpp
     nodemanager.cpp
     runrequestsloader.cpp

src/core/cm/launcher/balancer.cpp

@@ -16,14 +16,13 @@
 
 void Balancer::Init(InstanceManager& instanceManager, imagemanager::ItemInfoProviderItf& itemInfoProvider,
     oci::OCISpecItf& ociSpec, NodeManager& nodeManager, MonitoringProviderItf& monitorProvider,
-    InstanceRunnerItf& runner, NetworkManager& networkManager)
+    InstanceRunnerItf& runner)
 {
     mInstanceManager = &instanceManager;
     mImageInfoProvider.Init(itemInfoProvider, ociSpec);
     mNodeManager     = &nodeManager;
     mMonitorProvider = &monitorProvider;
     mRunner          = &runner;
-    mNetworkManager  = &networkManager;
 }
 
 Error Balancer::RunInstances(UniqueLock<Mutex>& lock, Array<SharedPtr<Instance>>& instances, bool rebalancing)
@@ -42,10 +41,6 @@
         return AOS_ERROR_WRAP(err);
     }
 
-    if (auto err = UpdateNetwork(); !err.IsNone()) {
-        return AOS_ERROR_WRAP(err);
-    }
-
     // Submit scheduled instances before sending them to nodes.
     // So status updates expecting by SendScheduledInstances will be assigned to active instances.
     if (auto err = mInstanceManager->SubmitScheduledInstances(); !err.IsNone()) {
@@ -159,7 +154,7 @@
     auto&       node    = nodeRuntime.mFirst;
     const auto& runtime = nodeRuntime.mSecond;
 
     if (auto err = mInstanceManager->ScheduleInstance(instance, *node, runtime->mRuntimeID); !err.IsNone()) {
         return AOS_ERROR_WRAP(Error(err, "can't schedule instance"));
     }
 
@@ -381,86 +376,6 @@
         [topPriority](const NodeRuntimes& item) { return item.mFirst->GetConfig().mPriority != topPriority; });
 }
 
-Error Balancer::UpdateNetwork()
-{
-    if (auto err = RemoveNetworkForDeletedInstances(); !err.IsNone()) {
-        return err;
-    }
-
-    if (auto err = SetupNetworkForNewInstances(); !err.IsNone()) {
-        return err;
-    }
-
-    if (auto err = SetNetworkParams(true); !err.IsNone()) {
-        return err;
-    }
-
-    if (auto err = SetNetworkParams(false); !err.IsNone()) {
-        return err;
-    }
-
-    if (auto err = mNetworkManager->RestartDNSServer(); !err.IsNone()) {
-        return AOS_ERROR_WRAP(err);
-    }
-
-    return ErrorEnum::eNone;
-}
-
-Error Balancer::RemoveNetworkForDeletedInstances()
-{
-    const auto& scheduledInstances = mInstanceManager->GetScheduledInstances();
-
-    for (const auto& instance : mInstanceManager->GetActiveInstances()) {
-        bool isScheduled = scheduledInstances.ContainsIf(
-            [&instance](const SharedPtr<Instance>& schedInst) { return schedInst.Get() == instance.Get(); });
-
-        if (!isScheduled) {
-            if (auto err = instance->RemoveNetworkParams(); !err.IsNone()) {
-                return AOS_ERROR_WRAP(err);
-            }
-        }
-    }
-
-    return ErrorEnum::eNone;
-}
-
-Error Balancer::SetNetworkParams(bool onlyWithExposedPorts)
-{
-    for (auto& instance : mInstanceManager->GetScheduledInstances()) {
-        auto err = instance->PrepareNetworkParams(onlyWithExposedPorts);
-        if (!err.IsNone()) {
-            instance->SetError(AOS_ERROR_WRAP(Error(err, "can't setup network params")));
-
-            continue;
-        }
-    }
-
-    return ErrorEnum::eNone;
-}
-
-Error Balancer::SetupNetworkForNewInstances()
-{
-    for (const auto& node : mNodeManager->GetNodes()) {
-        const auto& nodeID = node.GetInfo().mNodeID;
-
-        auto providers = MakeUnique<StaticArray<StaticString<cIDLen>, cMaxNumInstances>>(&mAllocator);
-
-        for (const auto& instance : mInstanceManager->GetScheduledInstances()) {
-            if (nodeID == instance->GetInfo().mNodeID) {
-                if (auto err = providers->PushBack(instance->GetInfo().mOwnerID); !err.IsNone()) {
-                    instance->SetError(AOS_ERROR_WRAP(Error(err, "can't add owner ID")));
-                }
-            }
-        }
-
-        if (auto err = mNetworkManager->UpdateProviderNetwork(*providers, nodeID); !err.IsNone()) {
-            return AOS_ERROR_WRAP(Error(err, "can't update provider network"));
-        }
-    }
-
-    return ErrorEnum::eNone;
-}
-
 Error Balancer::PerformPolicyBalancing(Array<SharedPtr<Instance>>& instances)
 {
     auto imageIndex = MakeUnique<oci::ImageIndex>(&mAllocator);
@@ -561,8 +476,6 @@
         return AOS_ERROR_WRAP(err);
     }
 
-    mNetworkManager->PrepareForBalancing();
-
     if (auto err = mInstanceManager->PrepareForBalancing(); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
     }

src/core/cm/launcher/balancer.hpp

@@ -34,11 +34,10 @@ class Balancer {
      * @param nodeManager node manager.
      * @param monitorProvider monitoring provider.
      * @param runner instance runner interface.
-     * @param networkManager network manager.
      */
     void Init(InstanceManager& instanceManager, imagemanager::ItemInfoProviderItf& itemInfoProvider,
         oci::OCISpecItf& ociSpec, NodeManager& nodeManager, MonitoringProviderItf& monitorProvider,
-        InstanceRunnerItf& runner, NetworkManager& networkManager);
+        InstanceRunnerItf& runner);
 
     /**
      * Runs instances.
@@ -62,11 +61,9 @@ class Balancer {
     static constexpr size_t cScheduleInstanceSize
         = sizeof(oci::ImageIndex) + sizeof(StaticArray<Node*, cMaxNumNodes>) + sizeof(NodeRuntimes);
     static constexpr size_t cPolicyBalancingSize = sizeof(oci::ImageIndex);
-    static constexpr size_t cNetworkSetupSize    = sizeof(StaticArray<StaticString<cIDLen>, cMaxNumInstances>);
     static constexpr size_t cMonitoringSize      = sizeof(monitoring::NodeMonitoringData);
 
-    static constexpr size_t cAllocatorSize
-        = Max(cScheduleInstanceSize, cPolicyBalancingSize, cNetworkSetupSize, cMonitoringSize);
+    static constexpr size_t cAllocatorSize = Max(cScheduleInstanceSize, cPolicyBalancingSize, cMonitoringSize);
 
     Error PerformNodeBalancing(Array<SharedPtr<Instance>>& instances);
 
@@ -93,11 +90,6 @@ class Balancer {
     void FilterTopPriorityNodes(NodeRuntimes& nodes);
     //
 
-    Error UpdateNetwork();
-    Error RemoveNetworkForDeletedInstances();
-    Error SetNetworkParams(bool onlyWithExposedPorts);
-    Error SetupNetworkForNewInstances();
-
     Error PerformPolicyBalancing(Array<SharedPtr<Instance>>& instances);
 
     Error PrepareForBalancing(bool rebalancing, bool isInitialUpdate = false);
@@ -107,7 +99,6 @@ class Balancer {
     InstanceManager*       mInstanceManager {};
     NodeManager*           mNodeManager {};
     MonitoringProviderItf* mMonitorProvider {};
-    NetworkManager*        mNetworkManager {};
     InstanceRunnerItf*     mRunner {};
     SubjectArray           mSubjects;
 

src/core/cm/launcher/instance.cpp

@@ -138,7 +138,7 @@
     // Optional params: architecture variant, OS, OS version, OS features
 
     if (!mImageConfig->mOS.IsEmpty()) {
         if (platformInfo.mOSInfo.mOS != mImageConfig->mOS) {
             return false;
         }
     }
@@ -174,7 +174,7 @@
     return true;
 }
 
 bool Instance::IsNodeIDOk(const String& nodeID)
 {
     return !mInfo.mDisableRebalancing || mInfo.mNodeID == nodeID;
 }
@@ -252,7 +252,7 @@
 
     auto& runtimes = mItemConfig->mRuntimes;
 
     if (runtimes.IsEmpty()) {
         static const char* cDefaultRuntimes[] = {
             "crun",
             "runc",
@@ -359,7 +359,6 @@
     mSMInfo.mStoragePath = "";
     mSMInfo.mStatePath   = "";
     // mSMInfo.mEnvVars is set in OverrideEnvVars().
-    mSMInfo.mNetworkParameters.Reset();
     mSMInfo.mMonitoringParams.Reset();
 
     if (auto err = SetActive(node.GetConfig().mNodeID, runtimeID); !err.IsNone()) {
@@ -369,30 +368,16 @@
     return ErrorEnum::eNone;
 }
 
-Error ComponentInstance::PrepareNetworkParams(bool onlyExposedPorts)
-{
-    (void)onlyExposedPorts;
-
-    return ErrorEnum::eNone;
-}
-
-Error ComponentInstance::RemoveNetworkParams()
-{
-    return ErrorEnum::eNone;
-}
-
 /***********************************************************************************************************************
  * ServiceInstance implementation
  **********************************************************************************************************************/
 
 ServiceInstance::ServiceInstance(const InstanceInfo& info, UIDPool& uidPool, GIDPool& gidPool, StorageItf& storage,
-    StorageState& storageState, ImageInfoProvider& imageInfoProvider, NetworkManager& networkManager,
-    Allocator& allocator)
+    StorageState& storageState, ImageInfoProvider& imageInfoProvider, Allocator& allocator)
     : Instance(info, storage, imageInfoProvider, allocator)
     , mUIDPool(uidPool)
     , mGIDPool(gidPool)
     , mStorageState(storageState)
-    , mNetworkManager(networkManager)
 {
 }
 
@@ -541,10 +526,6 @@
 
     // mSMInfo.mEnvVars is set in OverrideEnvVars().
 
-    if (auto err = SetupNetworkServiceData(); !err.IsNone()) {
-        return AOS_ERROR_WRAP(err);
-    }
-
     mSMInfo.mMonitoringParams.EmplaceValue();
     if (mItemConfig->mAlertRules.HasValue()) {
         mSMInfo.mMonitoringParams.GetValue().mAlertRules = mItemConfig->mAlertRules.GetValue();
@@ -561,31 +542,6 @@
     return ErrorEnum::eNone;
 }
 
-Error ServiceInstance::PrepareNetworkParams(bool onlyExposedPorts)
-{
-    auto err = mNetworkManager.PrepareInstanceNetworkParameters(
-        mInfo.mInstanceIdent, mInfo.mOwnerID, mInfo.mNodeID, onlyExposedPorts, mSMInfo.mNetworkParameters);
-    if (!err.IsNone()) {
-        return AOS_ERROR_WRAP(err);
-    }
-
-    return ErrorEnum::eNone;
-}
-
-Error ServiceInstance::RemoveNetworkParams()
-{
-    if (mSMInfo.mNetworkParameters.HasValue()) {
-        auto err = mNetworkManager.RemoveInstanceNetworkParameters(mInfo.mInstanceIdent, mInfo.mNodeID);
-        if (!err.IsNone()) {
-            return AOS_ERROR_WRAP(err);
-        }
-
-        mSMInfo.mNetworkParameters.Reset();
-    }
-
-    return ErrorEnum::eNone;
-}
-
 size_t ServiceInstance::GetRequestedCPU(const NodeConfig& nodeConfig, bool useMonitoringData)
 {
     assert(mItemConfig);
@@ -755,22 +711,6 @@
     return 0;
 }
 
-Error ServiceInstance::SetupNetworkServiceData()
-{
-    mNetworkServiceData.mExposedPorts       = mImageConfig->mConfig.mExposedPorts;
-    mNetworkServiceData.mAllowedConnections = mItemConfig->mAllowedConnections;
-
-    if (mItemConfig->mHostname.HasValue()) {
-        mNetworkServiceData.mHosts.PushBack(mItemConfig->mHostname.GetValue());
-    }
-
-    if (auto err = mNetworkManager.SetNetworkServiceData(mInfo.mInstanceIdent, mNetworkServiceData); !err.IsNone()) {
-        return AOS_ERROR_WRAP(err);
-    }
-
-    return ErrorEnum::eNone;
-}
-
 Error ServiceInstance::SetupStateStorage(const NodeConfig& nodeConfig, String& storagePath, String& statePath)
 {
     auto reqState   = GetReqStateSize(nodeConfig);