Refactor netwoek manager

CMakeLists.txt

@@ -102,7 +102,7 @@ if(NOT EXISTS ${AOS_CORE_LIB_DIR})
     FetchContent_Populate(
         aos_core_lib_cpp
         GIT_REPOSITORY https://github.com/aosedge/aos_core_lib_cpp.git
-        GIT_TAG develop
+        GIT_TAG feature_release_9.1
         SOURCE_DIR ${AOS_CORE_LIB_DIR}
     )
 endif()
@@ -111,7 +111,7 @@ if(NOT EXISTS ${AOS_CORE_API_DIR})
     FetchContent_Populate(
         aos_core_api
         GIT_REPOSITORY https://github.com/aosedge/aos_core_api.git
-        GIT_TAG develop
+        GIT_TAG feature_release_9.1
         SOURCE_DIR ${AOS_CORE_API_DIR}
     )
 endif()

src/cm/app/aoscore.cpp

@@ -71,7 +71,6 @@ void AosCore::Init(const std::string& configFile)
 
     InitDatabase();
     InitStorageState();
-    InitSMController();
 
     err = mAlerts.Init(mConfig.mAlerts, mCommunication, mCommunication);
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize alerts");
@@ -102,8 +101,7 @@ void AosCore::Init(const std::string& configFile)
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize unit config");
 
     err = mLauncher.Init(mConfig.mLauncher, mNodeInfoProvider, mSMController, mImageManager, mOCISpec, mUnitConfig,
-        mStorageState, mNetworkManager, mSMController, mAlerts, mIAMClient, utils::IsUIDValid, utils::IsGIDValid,
-        mDatabase);
+        mStorageState, mSMController, mAlerts, mIAMClient, utils::IsUIDValid, utils::IsGIDValid, mDatabase);
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize launcher");
 
     err = mUpdateManager.Init({mConfig.mUnitStatusSendTimeout}, mIAMClient, mIAMClient, mUnitConfig, mNodeInfoProvider,
@@ -112,8 +110,10 @@ void AosCore::Init(const std::string& configFile)
 
     mDNSServer.Init(mConfig.mDNSStoragePath, mConfig.mDNSIP);
 
-    err = mNetworkManager.Init(mDatabase, mCryptoProvider, mSMController, mDNSServer);
+    err = mNetworkManager.Init(mDatabase, mCryptoProvider, mDNSServer, &mSMController);
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize network manager");
+
+    InitSMController();
 }
 
 void AosCore::Start()
@@ -278,7 +278,7 @@ void AosCore::InitSMController()
     config.mCMServerURL = mConfig.mCMServerURL;
 
     auto err = mSMController.Init(config, mCommunication, mIAMClient, mCertLoader, mCryptoProvider, mImageManager,
-        mAlerts, mCommunication, mCommunication, mMonitoring, mLauncher, mNodeInfoProvider);
+        mAlerts, mCommunication, mCommunication, mMonitoring, mLauncher, mNodeInfoProvider, mNetworkManager);
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize SM controller");
 }
 

src/cm/communication/tests/communication.cpp

@@ -509,6 +509,7 @@ TEST_F(CMCommunicationTest, GetBlobsInfosTimeout)
     StaticArray<StaticString<oci::cDigestLen>, 1> digests;
     digests.EmplaceBack("sha256:3c3a4604a545cdc127456d94e421cd355bca5b528f4a9c1905b15da2eb4a4c6b");
 
+    // cppcheck-suppress templateRecursion
     auto blobsInfo = std::make_unique<StaticArray<BlobInfo, 1>>();
 
     auto err = mCommunication.GetBlobsInfos(digests, *blobsInfo);

src/cm/database/database.cpp

@@ -579,6 +579,121 @@ Error Database::RemoveNetworkInstance(const InstanceIdent& instanceIdent)
     return ErrorEnum::eNone;
 }
 
+Error Database::AddPendingConnection(const networkmanager::PendingConnection& connection)
+{
+    std::lock_guard lock {mMutex};
+
+    try {
+        PendingConnectionRow row;
+
+        FromAos(connection, row);
+        *mSession << "INSERT INTO pending_connections (requesterItemID, requesterSubjectID, requesterInstance, "
+                     "requesterType, requesterPreinstalled, nodeID, networkID, requesterIP, requesterSubnet, "
+                     "targetItemID, port, protocol) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);",
+            bind(row), now;
+    } catch (const std::exception& e) {
+        return AOS_ERROR_WRAP(common::utils::ToAosError(e));
+    }
+
+    return ErrorEnum::eNone;
+}
+
+Error Database::GetPendingConnectionsByTarget(
+    const String& targetItemID, Array<networkmanager::PendingConnection>& connections)
+{
+    std::lock_guard lock {mMutex};
+
+    try {
+        std::vector<PendingConnectionRow> rows;
+
+        *mSession << "SELECT requesterItemID, requesterSubjectID, requesterInstance, requesterType, "
+                     "requesterPreinstalled, nodeID, networkID, requesterIP, requesterSubnet, targetItemID, "
+                     "port, protocol FROM pending_connections WHERE targetItemID = ?;",
+            bind(targetItemID.CStr()), into(rows), now;
+
+        auto connection = std::make_unique<networkmanager::PendingConnection>();
+
+        connections.Clear();
+
+        for (const auto& row : rows) {
+            ToAos(row, *connection);
+
+            auto err = connections.PushBack(*connection);
+            AOS_ERROR_CHECK_AND_THROW(AOS_ERROR_WRAP(err), "can't add pending connection");
+        }
+    } catch (const std::exception& e) {
+        return AOS_ERROR_WRAP(common::utils::ToAosError(e));
+    }
+
+    return ErrorEnum::eNone;
+}
+
+Error Database::GetAllPendingConnections(Array<networkmanager::PendingConnection>& connections)
+{
+    std::lock_guard lock {mMutex};
+
+    try {
+        std::vector<PendingConnectionRow> rows;
+
+        *mSession << "SELECT requesterItemID, requesterSubjectID, requesterInstance, requesterType, "
+                     "requesterPreinstalled, nodeID, networkID, requesterIP, requesterSubnet, targetItemID, "
+                     "port, protocol FROM pending_connections;",
+            into(rows), now;
+
+        auto connection = std::make_unique<networkmanager::PendingConnection>();
+
+        connections.Clear();
+
+        for (const auto& row : rows) {
+            ToAos(row, *connection);
+
+            auto err = connections.PushBack(*connection);
+            AOS_ERROR_CHECK_AND_THROW(AOS_ERROR_WRAP(err), "can't add pending connection");
+        }
+    } catch (const std::exception& e) {
+        return AOS_ERROR_WRAP(common::utils::ToAosError(e));
+    }
+
+    return ErrorEnum::eNone;
+}
+
+Error Database::RemovePendingConnection(const networkmanager::PendingConnection& connection)
+{
+    std::lock_guard lock {mMutex};
+
+    try {
+        *mSession << "DELETE FROM pending_connections "
+                     "WHERE requesterItemID = ? AND requesterSubjectID = ? AND requesterInstance = ? "
+                     "AND requesterType = ? AND requesterPreinstalled = ? AND targetItemID = ? "
+                     "AND port = ? AND protocol = ?;",
+            bind(connection.mRequesterIdent.mItemID.CStr()), bind(connection.mRequesterIdent.mSubjectID.CStr()),
+            bind(connection.mRequesterIdent.mInstance), bind(connection.mRequesterIdent.mType.ToString().CStr()),
+            bind(connection.mRequesterIdent.mPreinstalled), bind(connection.mTargetItemID.CStr()),
+            bind(connection.mPort.CStr()), bind(connection.mProtocol.CStr()), now;
+    } catch (const std::exception& e) {
+        return AOS_ERROR_WRAP(common::utils::ToAosError(e));
+    }
+
+    return ErrorEnum::eNone;
+}
+
+Error Database::RemovePendingConnections(const InstanceIdent& requesterIdent)
+{
+    std::lock_guard lock {mMutex};
+
+    try {
+        *mSession << "DELETE FROM pending_connections "
+                     "WHERE requesterItemID = ? AND requesterSubjectID = ? AND requesterInstance = ? "
+                     "AND requesterType = ? AND requesterPreinstalled = ?;",
+            bind(requesterIdent.mItemID.CStr()), bind(requesterIdent.mSubjectID.CStr()), bind(requesterIdent.mInstance),
+            bind(requesterIdent.mType.ToString().CStr()), bind(requesterIdent.mPreinstalled), now;
+    } catch (const std::exception& e) {
+        return AOS_ERROR_WRAP(common::utils::ToAosError(e));
+    }
+
+    return ErrorEnum::eNone;
+}
+
 /***********************************************************************************************************************
  * launcher::StorageItf implementation
  **********************************************************************************************************************/
@@ -1070,6 +1185,22 @@ void Database::CreateTables()
                  ");",
         now;
 
+    *mSession << "CREATE TABLE IF NOT EXISTS pending_connections ("
+                 "requesterItemID TEXT,"
+                 "requesterSubjectID TEXT,"
+                 "requesterInstance INTEGER,"
+                 "requesterType TEXT,"
+                 "requesterPreinstalled INTEGER,"
+                 "nodeID TEXT,"
+                 "networkID TEXT,"
+                 "requesterIP TEXT,"
+                 "requesterSubnet TEXT,"
+                 "targetItemID TEXT,"
+                 "port TEXT,"
+                 "protocol TEXT"
+                 ");",
+        now;
+
     *mSession << "CREATE TABLE IF NOT EXISTS launcher_instances ("
                  "itemID TEXT,"
                  "subjectID TEXT,"
@@ -1204,6 +1335,41 @@ void Database::ToAos(const NetworkManagerInstanceRow& src, networkmanager::Insta
     DeserializeDNSServers(src.get<ToInt(NetworkManagerInstanceColumns::eDNSServers)>(), dst.mDNSServers);
 }
 
+void Database::FromAos(const networkmanager::PendingConnection& src, PendingConnectionRow& dst)
+{
+    dst.set<ToInt(PendingConnectionColumns::eRequesterItemID)>(src.mRequesterIdent.mItemID.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eRequesterSubjectID)>(src.mRequesterIdent.mSubjectID.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eRequesterInstance)>(src.mRequesterIdent.mInstance);
+    dst.set<ToInt(PendingConnectionColumns::eRequesterType)>(src.mRequesterIdent.mType.ToString().CStr());
+    dst.set<ToInt(PendingConnectionColumns::eRequesterPreinstalled)>(src.mRequesterIdent.mPreinstalled);
+    dst.set<ToInt(PendingConnectionColumns::eNodeID)>(src.mNodeID.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eNetworkID)>(src.mNetworkID.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eRequesterIP)>(src.mRequesterIP.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eRequesterSubnet)>(src.mRequesterSubnet.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eTargetItemID)>(src.mTargetItemID.CStr());
+    dst.set<ToInt(PendingConnectionColumns::ePort)>(src.mPort.CStr());
+    dst.set<ToInt(PendingConnectionColumns::eProtocol)>(src.mProtocol.CStr());
+}
+
+void Database::ToAos(const PendingConnectionRow& src, networkmanager::PendingConnection& dst)
+{
+    dst.mRequesterIdent.mItemID    = src.get<ToInt(PendingConnectionColumns::eRequesterItemID)>().c_str();
+    dst.mRequesterIdent.mSubjectID = src.get<ToInt(PendingConnectionColumns::eRequesterSubjectID)>().c_str();
+    dst.mRequesterIdent.mInstance  = src.get<ToInt(PendingConnectionColumns::eRequesterInstance)>();
+
+    auto err = dst.mRequesterIdent.mType.FromString(src.get<ToInt(PendingConnectionColumns::eRequesterType)>().c_str());
+    AOS_ERROR_CHECK_AND_THROW(AOS_ERROR_WRAP(err), "failed to parse instance type");
+
+    dst.mRequesterIdent.mPreinstalled = src.get<ToInt(PendingConnectionColumns::eRequesterPreinstalled)>();
+    dst.mNodeID                       = src.get<ToInt(PendingConnectionColumns::eNodeID)>().c_str();
+    dst.mNetworkID                    = src.get<ToInt(PendingConnectionColumns::eNetworkID)>().c_str();
+    dst.mRequesterIP                  = src.get<ToInt(PendingConnectionColumns::eRequesterIP)>().c_str();
+    dst.mRequesterSubnet              = src.get<ToInt(PendingConnectionColumns::eRequesterSubnet)>().c_str();
+    dst.mTargetItemID                 = src.get<ToInt(PendingConnectionColumns::eTargetItemID)>().c_str();
+    dst.mPort                         = src.get<ToInt(PendingConnectionColumns::ePort)>().c_str();
+    dst.mProtocol                     = src.get<ToInt(PendingConnectionColumns::eProtocol)>().c_str();
+}
+
 void Database::FromAos(const launcher::InstanceInfo& src, LauncherInstanceInfoRow& dst)
 {
     dst.set<ToInt(LauncherInstanceInfoColumns::eItemID)>(src.mInstanceIdent.mItemID.CStr());

src/cm/database/database.hpp

@@ -174,6 +174,48 @@ class Database : public DatabaseItf, public networkmanager::StorageItf {
      */
     Error RemoveNetworkInstance(const InstanceIdent& instanceIdent) override;
 
+    /**
+     * Adds pending connection.
+     *
+     * @param connection Pending connection.
+     * @return Error.
+     */
+    Error AddPendingConnection(const networkmanager::PendingConnection& connection) override;
+
+    /**
+     * Gets pending connections by target item ID.
+     *
+     * @param targetItemID Target item ID.
+     * @param[out] connections Pending connections.
+     * @return Error.
+     */
+    Error GetPendingConnectionsByTarget(
+        const String& targetItemID, Array<networkmanager::PendingConnection>& connections) override;
+
+    /**
+     * Gets all pending connections.
+     *
+     * @param[out] connections All pending connections.
+     * @return Error.
+     */
+    Error GetAllPendingConnections(Array<networkmanager::PendingConnection>& connections) override;
+
+    /**
+     * Removes a specific pending connection.
+     *
+     * @param connection Pending connection to remove.
+     * @return Error.
+     */
+    Error RemovePendingConnection(const networkmanager::PendingConnection& connection) override;
+
+    /**
+     * Removes all pending connections for a requester instance.
+     *
+     * @param requesterIdent Requester instance identifier.
+     * @return Error.
+     */
+    Error RemovePendingConnections(const InstanceIdent& requesterIdent) override;
+
     //
     // launcher::StorageItf interface
     //
@@ -364,6 +406,23 @@ class Database : public DatabaseItf, public networkmanager::StorageItf {
     using NetworkManagerInstanceRow = Poco::Tuple<std::string, std::string, uint64_t, std::string, bool, std::string,
         std::string, std::string, std::string, std::string>;
 
+    enum class PendingConnectionColumns : int {
+        eRequesterItemID = 0,
+        eRequesterSubjectID,
+        eRequesterInstance,
+        eRequesterType,
+        eRequesterPreinstalled,
+        eNodeID,
+        eNetworkID,
+        eRequesterIP,
+        eRequesterSubnet,
+        eTargetItemID,
+        ePort,
+        eProtocol
+    };
+    using PendingConnectionRow = Poco::Tuple<std::string, std::string, uint64_t, std::string, bool, std::string,
+        std::string, std::string, std::string, std::string, std::string, std::string>;
+
     enum class LauncherInstanceInfoColumns : int {
         eItemID = 0,
         eSubjectID,
@@ -435,6 +494,9 @@ class Database : public DatabaseItf, public networkmanager::StorageItf {
     static void FromAos(const networkmanager::Instance& src, NetworkManagerInstanceRow& dst);
     static void ToAos(const NetworkManagerInstanceRow& src, networkmanager::Instance& dst);
 
+    static void FromAos(const networkmanager::PendingConnection& src, PendingConnectionRow& dst);
+    static void ToAos(const PendingConnectionRow& src, networkmanager::PendingConnection& dst);
+
     static void FromAos(const launcher::InstanceInfo& src, LauncherInstanceInfoRow& dst);
     static void ToAos(const LauncherInstanceInfoRow& src, launcher::InstanceInfo& dst);