dropshell/src/servers.cpp

#include "servers.hpp"
#include "server_env.hpp"
#include "service_runner.hpp"
#include "utils/tableprint.hpp"
#include "utils/envmanager.hpp"
#include "utils/directories.hpp"
#include "services.hpp"
#include "config.hpp"
#include "templates.hpp"
#include <iostream>
#include <fstream>
#include <iomanip>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <execution>

namespace fs = boost::filesystem;

namespace dropshell {

std::vector<ServerInfo> get_configured_servers() {
    std::vector<ServerInfo> servers;

    std::vector<std::string> local_config_directories = get_global_config()->get_local_config_directories();
    if (local_config_directories.empty())
        return servers;

    for (int i = 0; i < local_config_directories.size(); i++) {
        std::string servers_dir = get_local_config_servers_path(i);
        if (!servers_dir.empty() && fs::exists(servers_dir)) {

            for (const auto& entry : fs::directory_iterator(servers_dir)) {
                if (fs::is_directory(entry)) {
                    std::string server_name = entry.path().filename().string();

                    server_env env(server_name);
                    if (!env.is_valid()) {
                        std::cerr << "Error: Invalid server environment file: " << entry.path().string() << std::endl;
                        continue;
                    }
                    servers.push_back({
                        server_name,
                        env.get_SSH_HOST(),
                        env.get_SSH_USER(),
                        env.get_SSH_PORT()
                    });
                }
            }
        }
    }

    return servers;
}

void list_servers() {
    auto servers = get_configured_servers();

    tableprint tp("All DropShell Servers");
    tp.add_row({"Name", "Address", "Health", "Ports"});

    std::for_each(std::execution::par, servers.begin(), servers.end(), [&](const ServerInfo& server) {

        std::map<std::string, ServiceStatus> status = service_runner::get_all_services_status(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 += service_runner::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({server.name, server.ssh_host, serviceticks, ports_used_str});
    });
    tp.print();
}

void show_server_details(const std::string& server_name) {
    server_env env(server_name);
    if (!env.is_valid()) {
        std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
        return;
    }

    //---------------------
    // Check if server is reachable via SSH
    std::string ssh_address = env.get_SSH_HOST();
    std::string ssh_user = env.get_SSH_USER();
    std::string ssh_port = env.get_SSH_PORT();
    if (!ssh_address.empty()) {
        std::cout << std::endl << "Server Status:" << std::endl;
        std::cout << std::string(40, '-') << std::endl;
        
        // Try to connect to the server
        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'echo connected' 2>/dev/null";
        int result = system(cmd.c_str());
        if (result == 0) {
            std::cout << "Status: Online" << std::endl;
            
            // // Get uptime if possible
            // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
            // int rval = system(cmd.c_str());
            // if (rval != 0) {
            //     std::cout << "Error: Failed to get uptime" << std::endl;
            // } 
        } else {
            std::cout << "Status: Offline" << std::endl;
        }
    }
    std::cout << std::endl;

    //---------------------
    {
        std::cout << std::endl;
        tableprint tp("Server Configuration: " + server_name, true);
        tp.add_row({"Key", "Value"});
        for (const auto& [key, value] : env.get_variables()) {
            tp.add_row({key, value});
        }
        tp.print();
    }

    //---------------------
    // list services, and run healthcheck on each
    {
        tableprint tp("Services: " + server_name, false);
        tp.add_row({"Status", "Service", "Ports"});
        

        std::map<std::string, ServiceStatus> status = service_runner::get_all_services_status(server_name); 

        std::set<int> ports_used;
        std::string serviceticks = "";
        for (const auto& [service_name, service_status] : status) {
            std::string healthy = service_runner::HealthStatus2String(service_status.health);
            
            std::string ports_str = "";
            for (const auto& port : service_status.ports) 
                ports_str += std::to_string(port) + " ";
        
            tp.add_row({healthy, service_name, ports_str});
        } // end of for (const auto& service : services)
        tp.print();
    } // end of list services
} // end of show_server_details

} // namespace dropshell