Enhancement/14 add key to register and authentication

.github/actions/compile/action.yml

@@ -30,9 +30,9 @@ runs:
         shell: bash
 
       - name: Run Tests
-        continue-on-error: true
+        continue-on-error: false
         run: |
           set +e
           cd build
-          ctest || echo "Tests failed, but continuing"
+          ctest
         shell: bash

src/agent/agent_info/include/agent_info.hpp

@@ -6,18 +6,18 @@ class AgentInfo
 {
 public:
     AgentInfo();
-    AgentInfo(const std::string& name, const std::string& ip, const std::string& uuid);
+    AgentInfo(const std::string& name, const std::string& key, const std::string& uuid);
 
     std::string GetName() const;
-    std::string GetIP() const;
+    std::string GetKey() const;
     std::string GetUUID() const;
 
     void SetName(const std::string& name);
-    void SetIP(const std::string& ip);
+    void SetKey(const std::string& key);
     void SetUUID(const std::string& uuid);
 
 private:
     std::string m_name;
-    std::string m_ip;
+    std::string m_key;
     std::string m_uuid;
 };

src/agent/agent_info/include/agent_info_persistance.hpp

@@ -22,11 +22,11 @@ class AgentInfoPersistance
     AgentInfoPersistance& operator=(AgentInfoPersistance&&) = delete;
 
     std::string GetName() const;
-    std::string GetIP() const;
+    std::string GetKey() const;
     std::string GetUUID() const;
 
     void SetName(const std::string& name);
-    void SetIP(const std::string& ip);
+    void SetKey(const std::string& key);
     void SetUUID(const std::string& uuid);
 
     void ResetToDefault();

src/agent/agent_info/src/agent_info.cpp

@@ -9,7 +9,7 @@ AgentInfo::AgentInfo()
 {
     AgentInfoPersistance agentInfoPersistance;
     m_name = agentInfoPersistance.GetName();
-    m_ip = agentInfoPersistance.GetIP();
+    m_key = agentInfoPersistance.GetKey();
     m_uuid = agentInfoPersistance.GetUUID();
 
     if (m_uuid.empty())
@@ -20,24 +20,24 @@ AgentInfo::AgentInfo()
     }
 }
 
-AgentInfo::AgentInfo(const std::string& name, const std::string& ip, const std::string& uuid)
+AgentInfo::AgentInfo(const std::string& name, const std::string& key, const std::string& uuid)
     : m_name(name)
-    , m_ip(ip)
+    , m_key(key)
     , m_uuid(uuid)
 {
     AgentInfoPersistance agentInfoPersistance;
     agentInfoPersistance.SetName(m_name);
-    agentInfoPersistance.SetIP(m_ip);
+    agentInfoPersistance.SetKey(m_key);
     agentInfoPersistance.SetUUID(m_uuid);
 }
 
 std::string AgentInfo::GetName() const
 {
     return m_name;
 }
-std::string AgentInfo::GetIP() const
+std::string AgentInfo::GetKey() const
 {
-    return m_ip;
+    return m_key;
 }
 std::string AgentInfo::GetUUID() const
 {
@@ -51,11 +51,11 @@ void AgentInfo::SetName(const std::string& name)
     m_name = name;
 }
 
-void AgentInfo::SetIP(const std::string& ip)
+void AgentInfo::SetKey(const std::string& key)
 {
     AgentInfoPersistance agentInfoPersistance;
-    agentInfoPersistance.SetIP(ip);
-    m_ip = ip;
+    agentInfoPersistance.SetKey(key);
+    m_key = key;
 }
 
 void AgentInfo::SetUUID(const std::string& uuid)

src/agent/agent_info/src/agent_info_persistance.cpp

@@ -66,7 +66,7 @@ void AgentInfoPersistance::CreateAgentInfoTable()
     {
         m_db->exec("CREATE TABLE IF NOT EXISTS agent_info ("
                    "name TEXT, "
-                   "ip TEXT, "
+                   "key TEXT, "
                    "uuid TEXT"
                    ");");
     }
@@ -86,7 +86,7 @@ void AgentInfoPersistance::InsertDefaultAgentInfo()
 
         if (count == 0)
         {
-            SQLite::Statement insert(*m_db, "INSERT INTO agent_info (name, ip, uuid) VALUES (?, ?, ?);");
+            SQLite::Statement insert(*m_db, "INSERT INTO agent_info (name, key, uuid) VALUES (?, ?, ?);");
             insert.exec();
         }
     }
@@ -133,9 +133,9 @@ std::string AgentInfoPersistance::GetName() const
     return GetAgentInfoValue("name");
 }
 
-std::string AgentInfoPersistance::GetIP() const
+std::string AgentInfoPersistance::GetKey() const
 {
-    return GetAgentInfoValue("ip");
+    return GetAgentInfoValue("key");
 }
 
 std::string AgentInfoPersistance::GetUUID() const
@@ -148,9 +148,9 @@ void AgentInfoPersistance::SetName(const std::string& name)
     SetAgentInfoValue("name", name);
 }
 
-void AgentInfoPersistance::SetIP(const std::string& ip)
+void AgentInfoPersistance::SetKey(const std::string& key)
 {
-    SetAgentInfoValue("ip", ip);
+    SetAgentInfoValue("key", key);
 }
 
 void AgentInfoPersistance::SetUUID(const std::string& uuid)

src/agent/agent_info/tests/agent_info_persistance_test.cpp

@@ -25,7 +25,7 @@ TEST_F(AgentInfoPersistanceTest, TestConstruction)
 TEST_F(AgentInfoPersistanceTest, TestDefaultValues)
 {
     EXPECT_EQ(persistance->GetName(), "");
-    EXPECT_EQ(persistance->GetIP(), "");
+    EXPECT_EQ(persistance->GetKey(), "");
     EXPECT_EQ(persistance->GetUUID(), "");
 }
 
@@ -36,11 +36,11 @@ TEST_F(AgentInfoPersistanceTest, TestSetName)
     EXPECT_EQ(persistance->GetName(), newName);
 }
 
-TEST_F(AgentInfoPersistanceTest, TestSetIP)
+TEST_F(AgentInfoPersistanceTest, TestSetKey)
 {
-    const std::string newIP = "192.168.1.1";
-    persistance->SetIP(newIP);
-    EXPECT_EQ(persistance->GetIP(), newIP);
+    const std::string newKey = "new_key";
+    persistance->SetKey(newKey);
+    EXPECT_EQ(persistance->GetKey(), newKey);
 }
 
 TEST_F(AgentInfoPersistanceTest, TestSetUUID)
@@ -58,7 +58,7 @@ TEST_F(AgentInfoPersistanceTest, TestResetToDefault)
 
     persistance->ResetToDefault();
     EXPECT_EQ(persistance->GetName(), "");
-    EXPECT_EQ(persistance->GetIP(), "");
+    EXPECT_EQ(persistance->GetKey(), "");
     EXPECT_EQ(persistance->GetUUID(), "");
 }
 

src/agent/agent_info/tests/agent_info_test.cpp

@@ -23,28 +23,28 @@ TEST_F(AgentInfoTest, TestDefaultConstructorDefaultValues)
 {
     const AgentInfo agentInfo;
     EXPECT_EQ(agentInfo.GetName(), "");
-    EXPECT_EQ(agentInfo.GetIP(), "");
+    EXPECT_EQ(agentInfo.GetKey(), "");
     EXPECT_NE(agentInfo.GetUUID(), "");
 }
 
 TEST_F(AgentInfoTest, TestParameterizedConstructor)
 {
     const std::string name = "new_name";
-    const std::string ip = "192.168.1.1";
+    const std::string key = "new_key";
     const std::string uuid = "new_uuid";
 
-    const AgentInfo agentInfo(name, ip, uuid);
+    const AgentInfo agentInfo(name, key, uuid);
     EXPECT_EQ(agentInfo.GetName(), name);
-    EXPECT_EQ(agentInfo.GetIP(), ip);
+    EXPECT_EQ(agentInfo.GetKey(), key);
     EXPECT_EQ(agentInfo.GetUUID(), uuid);
 }
 
 TEST_F(AgentInfoTest, TestPersistedValues)
 {
-    const AgentInfo agentInfo("test_name", "test_ip", "test_uuid");
+    const AgentInfo agentInfo("test_name", "test_key", "test_uuid");
     const AgentInfo agentInfoReloaded;
     EXPECT_EQ(agentInfoReloaded.GetName(), "test_name");
-    EXPECT_EQ(agentInfoReloaded.GetIP(), "test_ip");
+    EXPECT_EQ(agentInfoReloaded.GetKey(), "test_key");
     EXPECT_EQ(agentInfoReloaded.GetUUID(), "test_uuid");
 }
 
@@ -60,16 +60,16 @@ TEST_F(AgentInfoTest, TestSetName)
     EXPECT_EQ(agentInfoReloaded.GetName(), newName);
 }
 
-TEST_F(AgentInfoTest, TestSetIP)
+TEST_F(AgentInfoTest, TestSetKey)
 {
     AgentInfo agentInfo;
-    const std::string newIP = "192.168.1.1";
+    const std::string newKey = "new_key";
 
-    agentInfo.SetIP(newIP);
-    EXPECT_EQ(agentInfo.GetIP(), newIP);
+    agentInfo.SetKey(newKey);
+    EXPECT_EQ(agentInfo.GetKey(), newKey);
 
     const AgentInfo agentInfoReloaded;
-    EXPECT_EQ(agentInfoReloaded.GetIP(), newIP);
+    EXPECT_EQ(agentInfoReloaded.GetKey(), newKey);
 }
 
 TEST_F(AgentInfoTest, TestSetUUID)

src/agent/communicator/include/communicator.hpp

@@ -17,6 +17,7 @@ namespace communicator
     {
     public:
         Communicator(const std::string& uuid,
+                     const std::string& key,
                      const std::function<std::string(std::string, std::string)> GetStringConfigValue);
 
         boost::asio::awaitable<void> WaitForTokenExpirationAndAuthenticate();
@@ -37,6 +38,7 @@ namespace communicator
         std::string m_managerIp;
         std::string m_port;
         std::string m_uuid;
+        std::string m_key;
         std::string m_token;
         long long m_tokenExpTimeInSeconds = 0;
         std::unique_ptr<boost::asio::steady_timer> m_tokenExpTimer;

src/agent/communicator/include/http_client.hpp

@@ -54,10 +54,15 @@ namespace http_client
 
     boost::beast::http::response<boost::beast::http::dynamic_body> PerformHttpRequest(const HttpRequestParams& params);
 
-    std::optional<std::string>
-    AuthenticateWithUuid(const std::string& host, const std::string& port, const std::string& uuid);
-    std::optional<std::string> AuthenticateWithUserPassword(const std::string& host,
-                                                            const std::string& port,
-                                                            const std::string& user,
-                                                            const std::string& password);
+    std::optional<std::string> AuthenticateWithUuidAndKey(const std::string& host,
+                                                          const std::string& port,
+                                                          const std::string& uuid,
+                                                          const std::string& key);
+
+    using AuthenticateFunctionType = std::optional<std::string>(const std::string& host,
+                                                                const std::string& port,
+                                                                const std::string& user,
+                                                                const std::string& password);
+
+    AuthenticateFunctionType AuthenticateWithUserPassword;
 } // namespace http_client

src/agent/communicator/src/communicator.cpp

@@ -18,8 +18,10 @@ namespace communicator
     constexpr int TokenPreExpirySecs = 2;
 
     Communicator::Communicator(const std::string& uuid,
+                               const std::string& key,
                                const std::function<std::string(std::string, std::string)> GetStringConfigValue)
         : m_uuid(uuid)
+        , m_key(key)
     {
         if (GetStringConfigValue != nullptr)
         {
@@ -30,7 +32,7 @@ namespace communicator
 
     boost::beast::http::status Communicator::SendAuthenticationRequest()
     {
-        const auto token = http_client::AuthenticateWithUuid(m_managerIp, m_port, m_uuid);
+        const auto token = http_client::AuthenticateWithUuidAndKey(m_managerIp, m_port, m_uuid, m_key);
 
         if (token.has_value())
         {

src/agent/communicator/src/http_client.cpp

@@ -182,12 +182,14 @@ namespace http_client
         return res;
     }
 
-    std::optional<std::string>
-    AuthenticateWithUuid(const std::string& host, const std::string& port, const std::string& uuid)
+    std::optional<std::string> AuthenticateWithUuidAndKey(const std::string& host,
+                                                          const std::string& port,
+                                                          const std::string& uuid,
+                                                          const std::string& key)
     {
-        const std::string uuidKeyValue = "{\"uuid\":\"" + uuid + "\"}";
-        const auto reqParams = http_client::HttpRequestParams(
-            boost::beast::http::verb::post, host, port, "/authentication", "", "", uuidKeyValue);
+        const std::string body = "{\"uuid\":\"" + uuid + "\", \"key\":\"" + key + "\"}";
+        const auto reqParams =
+            http_client::HttpRequestParams(boost::beast::http::verb::post, host, port, "/authentication", "", "", body);
 
         return GetTokenFromResponse(reqParams);
     }

src/agent/communicator/tests/communicator_test.cpp

@@ -4,7 +4,7 @@
 
 TEST(CommunicatorTest, CommunicatorConstructor)
 {
-    EXPECT_NO_THROW(communicator::Communicator communicator("uuid", nullptr));
+    EXPECT_NO_THROW(communicator::Communicator communicator("uuid", "key", nullptr));
 }
 
 int main(int argc, char** argv)

src/agent/include/register.hpp

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <http_client.hpp>
+
+#include <boost/beast/http.hpp>
+#include <functional>
 #include <optional>
 #include <string>
 
@@ -11,5 +15,17 @@ namespace registration
         std::string password;
     };
 
-    bool RegisterAgent(const UserCredentials& userCredentials);
+    using RegisterFunctionType = boost::beast::http::status(const std::string& host,
+                                                            const std::string& port,
+                                                            const std::string& token,
+                                                            const std::string& uuid,
+                                                            const std::string& key,
+                                                            const std::optional<std::string>& name);
+
+    RegisterFunctionType SendRegistrationRequest;
+
+    bool RegisterAgent(const UserCredentials& userCredentials,
+                       std::function<http_client::AuthenticateFunctionType> AuthenticateFunction,
+                       std::function<RegisterFunctionType> RegisterFunction);
+
 } // namespace registration

src/agent/src/agent.cpp

@@ -4,6 +4,7 @@
 
 Agent::Agent()
     : m_communicator(m_agentInfo.GetUUID(),
+                     m_agentInfo.GetKey(),
                      [this](std::string table, std::string key) -> std::string
                      { return m_configurationParser.GetConfig<std::string>(table, key); })
 {