Big refactor

source/src/commands/backupdata.cpp

@@ -11,7 +11,7 @@
 #include "config.hpp"
 #include "services.hpp"
 #include "servers.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "templates.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
@@ -55,7 +55,7 @@ namespace dropshell
 
         bool backupdata_service(const std::string &server, const std::string &service)
         {
-            server_env_manager server_env(server);
+            server_config server_env(server);
             if (!server_env.is_valid())
             {
                 error << "Server " << server << " is not valid" << std::endl;

source/src/commands/destroy.cpp

@@ -2,7 +2,7 @@
 #include "shared_commands.hpp"
 #include "config.hpp"
 #include "services.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "utils/directories.hpp"
 #include "servers.hpp"
 #include "templates.hpp"
@@ -52,7 +52,7 @@ namespace dropshell
 
         bool nuke_service(const std::string &server, const std::string &service)
         {
-            server_env_manager server_env(server);
+            server_config server_env(server);
 
             // step 1 - nuke on remote server.
             if (server_env.is_valid())

source/src/commands/health.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "transwarp.hpp"

source/src/commands/install.cpp

@@ -69,7 +69,7 @@ namespace dropshell
             if (!SIvalid(service_info))
                 return false;
 
-            server_env_manager server_env(server);
+            server_config server_env(server);
             if (!server_env.is_valid())
                 return false;
 
@@ -90,9 +90,10 @@ namespace dropshell
             }
 
             // Create service directory
-            std::string remote_service_path = remotepath::service(server, service);
+            std::string user = server_env.get_user_for_service(server, service);
+            std::string remote_service_path = remotepath(server,user).service(service);
             std::string mkdir_cmd = "mkdir -p " + quote(remote_service_path);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Silent))
             {
                 std::cerr << "Failed to create service directory " << remote_service_path << std::endl;
                 return false;
@@ -100,7 +101,7 @@ namespace dropshell
 
             // Check if rsync is installed on remote host
             std::string check_rsync_cmd = "which rsync";
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", check_rsync_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", check_rsync_cmd, {}), cMode::Silent))
             {
                 std::cerr << "rsync is not installed on the remote host" << std::endl;
                 return false;
@@ -108,8 +109,8 @@ namespace dropshell
 
             // Copy template files
             debug << "Copying: [LOCAL] " << tinfo.local_template_path() << std::endl
-                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_template(server, service) << "/" << std::endl;
-            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath::service_template(server, service),
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath(server,user).service_template(service) << "/" << std::endl;
+            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath(server,user).service_template(service),
                                                        server_env, false))
             {
                 std::cerr << "Failed to copy template files using rsync" << std::endl;
@@ -118,8 +119,8 @@ namespace dropshell
 
             // Copy service files
             debug << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
-                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_config(server, service) << std::endl;
-            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath::service_config(server, service),
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath(server,user).service_config(service) << std::endl;
+            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath(server,user).service_config(service),
                                                        server_env, false))
             {
                 std::cerr << "Failed to copy service files using rsync" << std::endl;
@@ -263,36 +264,38 @@ namespace dropshell
         // install the dropshell agent on the given server.
         maketitle("Installing dropshell agent on " + server, sColour::INFO);
 
-        std::string agent_path = remotepath::agent(server);
-        if (agent_path.empty())
-        {
-            error << "Failed to get agent path for " << server << std::endl;
-            return 1;
-        }
-
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Invalid server environment for " << server << std::endl;
             return 1;
         }
 
-        // now create the agent.
-        // copy across from the local agent files.
-        info << "Copying local agent files to remote server... " << std::flush;
-        shared_commands::rsync_tree_to_remote(localpath::agent_remote(), agent_path, server_env, false);
-        info << "done." << std::endl;
-
-        // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
-        
-        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
-        if (!okay)
+        for (const auto &user : server_env.get_users())
         {
-            error << "ERROR: Failed to install remote agent on " << server << std::endl;
-            return 1;
-        }
+            info << "Installing agent for user " << user.user << " on " << server << std::endl;
 
-        info << "Installation on " << server << " complete." << std::endl;
+            std::string agent_path = remotepath(server,user.user).agent();
+            ASSERT(agent_path == user.dir, "Agent path does not match user directory for "+user.user+"@" + server + " : " + agent_path + " != " + user.dir);
+            ASSERT(!agent_path.empty(), "Agent path is empty for " + user.user + "@" + server);
+
+            // now create the agent.
+            // copy across from the local agent files.
+            info << "Copying local agent files to remote server... " << std::flush;
+            shared_commands::rsync_tree_to_remote(localpath::agent_remote(), agent_path, server_env, false);
+            info << "done." << std::endl;
+
+            // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
+            
+            bool okay = execute_ssh_command(server_env.get_SSH_INFO(user.user), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
+            if (!okay)
+            {
+                error << "ERROR: Failed to install remote agent on " << server << std::endl;
+                return 1;
+            }
+
+            info << "Installation on " << server << " complete." << std::endl;
+        }
         return 0;
     }
 
@@ -313,10 +316,10 @@ namespace dropshell
             return rval;
 
         // install the dropshell agent on all servers.
-        std::vector<ServerInfo> servers = get_configured_servers();
+        std::vector<server_config> servers = get_configured_servers();
         for (const auto &server : servers)
         {
-            rval = install_server(server.name);
+            rval = install_server(server.get_server_name());
             if (rval != 0)
                 return rval;
         }

source/src/commands/list.cpp

@@ -6,7 +6,7 @@
 #include "servers.hpp"
 #include "tableprint.hpp"
 #include "transwarp.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 
 #include <unistd.h>
@@ -81,26 +81,40 @@ void list_servers() {
     }
 
     tableprint tp("All DropShell Servers");
-    tp.add_row({"Name", "User", "Address", "Health", "Ports"});
+    tp.add_row({"Name", "Address", "User", "Health", "Ports"});
 
     info << "Checking "<<servers.size() << " servers: " << std::flush;
     int checked = 0;
 
     transwarp::parallel exec{servers.size()};
-    auto task = transwarp::for_each(exec, servers.begin(), servers.end(), [&](const ServerInfo& server) {
-        std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server.name); 
+    auto task = transwarp::for_each(exec, servers.begin(), servers.end(), [&](const server_config& server) {
 
-        std::set<int> ports_used;
-        std::string serviceticks = "";
-        for (const auto& [service_name, service_status] : status) {
-            ports_used.insert(service_status.ports.begin(), service_status.ports.end());
-            serviceticks += shared_commands::HealthStatus2String(service_status.health) + " ";
+        server_config server_env(server.get_server_name());
+        if (!server_env.is_valid())
+        {
+            error << "Invalid server environment for " << server.get_server_name() << std::endl;
+            return;
         }
-        std::string ports_used_str = "";
-        for (const auto& port : ports_used) 
-            ports_used_str += std::to_string(port) + " ";
-        
-        tp.add_row({server.name, server.ssh_user, server.ssh_host, serviceticks, ports_used_str});
+
+        int first=true;
+        for (const auto &user : server_env.get_users())
+            {
+            std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server.get_server_name()); 
+
+            std::set<int> ports_used;
+            std::string serviceticks = "";
+            for (const auto& [service_name, service_status] : status) {
+                ports_used.insert(service_status.ports.begin(), service_status.ports.end());
+                serviceticks += shared_commands::HealthStatus2String(service_status.health) + " ";
+            }
+            std::string ports_used_str = "";
+            for (const auto& port : ports_used) 
+                ports_used_str += std::to_string(port) + " ";
+
+            tp.add_row({(first ? server.get_server_name() : ""), (first ? server.get_SSH_HOST() : ""), user.user, serviceticks, ports_used_str});
+            first = false;
+            }
+
         ++checked;
         // print out a tick character for each server checked.
         info << checked << " ✓  " << std::flush;
@@ -114,7 +128,7 @@ void list_servers() {
 
 
 void show_server_details(const std::string& server_name) {
-    server_env_manager env(server_name);
+    server_config env(server_name);
     if (!env.is_valid()) {
         error << "Error: Invalid server environment file: " << server_name << std::endl;
         return;

source/src/commands/restoredata.cpp

@@ -11,7 +11,7 @@
 #include "config.hpp"
 #include "services.hpp"
 #include "servers.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "templates.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
@@ -92,7 +92,7 @@ namespace dropshell
         std::string service = ctx.args[1];
         std::string backup_arg = ctx.args[2];
 
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;

source/src/commands/shared_commands.cpp

@@ -1,7 +1,7 @@
 #include "shared_commands.hpp"
 #include "utils/assert.hpp"
 #include "utils/utils.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "directories.hpp"
 #include "services.hpp"
 #include "servers.hpp"
@@ -21,10 +21,10 @@ namespace dropshell
             if (ctx.args.size() == 0)
             { // just the command, no args yet.
                 // list servers
-                std::vector<ServerInfo> servers = get_configured_servers();
+                std::vector<server_config> servers = get_configured_servers();
                 for (const auto &server : servers)
                 {
-                    rawout << server.name << std::endl;
+                    rawout << server.get_server_name() << std::endl;
                 }
             }
             else if (ctx.args.size() == 1)
@@ -54,7 +54,7 @@ namespace dropshell
         bool rsync_tree_to_remote(
             const std::string &local_path,
             const std::string &remote_path,
-            server_env_manager &server_env,
+            server_config &server_env,
             bool silent)
         {
             ASSERT(!local_path.empty() && !remote_path.empty(), "Local or remote path not specified. Can't rsync.");
@@ -84,7 +84,7 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // cRemoteTempFolder : SHARED CLASS
         // ------------------------------------------------------------------------------------------------
-        cRemoteTempFolder::cRemoteTempFolder(const server_env_manager &server_env, std::string user) : 
+        cRemoteTempFolder::cRemoteTempFolder(const server_config &server_env, std::string user) : 
         mServerEnv(server_env), mUser(user)
         {
             std::string p = remotepath(server_env.get_server_name(),user).temp_files() + "/" + random_alphanumeric_string(10);
@@ -113,7 +113,7 @@ namespace dropshell
         {
             std::map<std::string, ServiceStatus> status;
 
-            server_env_manager env(server_name);
+            server_config env(server_name);
             if (!env.is_valid())
             {
                 error << "Invalid server environment" << std::endl;
@@ -214,7 +214,7 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         HealthStatus is_healthy(const std::string &server, const std::string &service)
         {
-            server_env_manager env(server);
+            server_config env(server);
             if (!env.is_valid())
             {
                 error << "Server service not initialized" << std::endl;
@@ -307,7 +307,7 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // scp_file_to_remote : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent)
+        bool scp_file_to_remote(const server_config &server_env, const std::string &local_path, const std::string &remote_path, bool silent)
         {
             if (!server_env.is_valid())
             {
@@ -322,7 +322,7 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // scp_file_from_remote : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent)
+        bool scp_file_from_remote(const server_config &server_env, const std::string &remote_path, const std::string &local_path, bool silent)
         {
             if (!server_env.is_valid())
             {

source/src/commands/shared_commands.hpp

@@ -3,7 +3,7 @@
 
 #include "servers.hpp"
 #include "command_registry.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 
 namespace dropshell
 {
@@ -31,19 +31,19 @@ namespace dropshell
     class cRemoteTempFolder
     {
     public:
-        cRemoteTempFolder(const server_env_manager &server_env, std::string user); // create a temp folder on the remote server
+        cRemoteTempFolder(const server_config &server_env, std::string user); // create a temp folder on the remote server
         ~cRemoteTempFolder();                                    // delete the temp folder on the remote server
         std::string path() const;                                // get the path to the temp folder on the remote server
     private:
         std::string mPath;
-        const server_env_manager &mServerEnv;
+        const server_config &mServerEnv;
         std::string mUser;
     };
 
     bool rsync_tree_to_remote(
         const std::string &local_path,
         const std::string &remote_path,
-        server_env_manager &server_env,
+        server_config &server_env,
         bool silent);
 
     std::string get_arch();
@@ -79,8 +79,8 @@ namespace dropshell
         std::string mDatetime;
     };
 
-    bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent);
-    bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent);
+    bool scp_file_to_remote(const server_config &server_env, const std::string &local_path, const std::string &remote_path, bool silent);
+    bool scp_file_from_remote(const server_config &server_env, const std::string &remote_path, const std::string &local_path, bool silent);
 
     // defined in backupdata.cpp, used by restoredata.cpp.
     bool backupdata_service(const std::string& server, const std::string& service);

source/src/commands/ssh.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "templates.hpp"
@@ -42,7 +42,7 @@ namespace dropshell
 
     bool ssh_into_server(const std::string &server, std::string user)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
@@ -54,7 +54,7 @@ namespace dropshell
 
     bool ssh_into_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
@@ -109,7 +109,7 @@ namespace dropshell
                 server = arg1;
 
                 // get the first user from the server.env file, and ssh in as that user.
-                server_env_manager server_env(server);
+                server_config server_env(server);
                 if (!server_env.is_valid())
                 {
                     error << "Server " << server << " is not valid" << std::endl;

source/src/commands/start.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "utils/output.hpp"
@@ -44,7 +44,7 @@ namespace dropshell
 
     bool start_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;

source/src/commands/stop.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "utils/output.hpp"
@@ -44,7 +44,7 @@ namespace dropshell
 
     bool stop_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;

source/src/commands/uninstall.cpp

@@ -46,7 +46,7 @@ namespace dropshell
         {
             maketitle("Uninstalling " + service + " on " + server);
 
-            server_env_manager server_env(server);
+            server_config server_env(server);
             if (!server_env.is_valid())
             {
                 error << "Invalid server: " << server << std::endl;