Compare commits
6 Commits
2025.0519.
...
2025.0521.
| Author | SHA1 | Date | |
|---|---|---|---|
| b3a57f13dc | |||
| 270d6ef792 | |||
| 9063edb45f | |||
| fc6b310b89 | |||
| 7a710b525f | |||
| 1b16741288 |
@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.10)
|
||||
project(dropshell VERSION 1.0.0 LANGUAGES CXX)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 23)
|
||||
set(CMAKE_C_STANDARD 23)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
|
||||
# Set default build type to Release if not specified
|
||||
|
||||
@ -50,7 +50,7 @@ function install_bb64() {
|
||||
_die "Curl is not installed. Curl is required for agent installation."
|
||||
fi
|
||||
|
||||
curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
|
||||
curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_LOCAL_PATH" "$(id -u $USER):$(id -g $USER)"
|
||||
|
||||
# test result code from curl
|
||||
if [ $? -ne 0 ]; then
|
||||
@ -58,7 +58,7 @@ function install_bb64() {
|
||||
fi
|
||||
|
||||
# test if bb64 is installed
|
||||
"$AGENT_PATH/bb64" -v
|
||||
"$AGENT_LOCAL_PATH/bb64" -v
|
||||
if [ $? -ne 0 ]; then
|
||||
_die "bb64 did not install correctly."
|
||||
fi
|
||||
@ -71,11 +71,11 @@ function install_bb64() {
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
set -a
|
||||
AGENT_PATH="$SCRIPT_DIR"
|
||||
AGENT_LOCAL_PATH="$SCRIPT_DIR"
|
||||
set +a
|
||||
|
||||
_check_required_env_vars "AGENT_PATH"
|
||||
echo "Installing host agent into $AGENT_PATH"
|
||||
_check_required_env_vars "AGENT_LOCAL_PATH"
|
||||
echo "Installing host agent into $AGENT_LOCAL_PATH"
|
||||
|
||||
_check_docker_installed || _die "Docker is required."
|
||||
|
||||
|
||||
@ -12,6 +12,10 @@ _autocommandrun_volume() {
|
||||
|
||||
case "$command" in
|
||||
create)
|
||||
if docker volume ls | grep -q ${volume_name}; then
|
||||
echo "Volume ${volume_name} already exists - leaving unchanged"
|
||||
return
|
||||
fi
|
||||
echo "Creating volume ${volume_name}"
|
||||
docker volume create ${volume_name}
|
||||
;;
|
||||
@ -39,6 +43,10 @@ _autocommandrun_path() {
|
||||
|
||||
case "$command" in
|
||||
create)
|
||||
if [ -d "${path}" ]; then
|
||||
echo "Path ${path} already exists - unchanged"
|
||||
return
|
||||
fi
|
||||
echo "Creating path ${path}"
|
||||
mkdir -p ${path}
|
||||
;;
|
||||
@ -80,6 +88,12 @@ _autocommandrun_file() {
|
||||
|
||||
case "$command" in
|
||||
create)
|
||||
filepath_parent=$(dirname ${filepath})
|
||||
filepath_child=$(basename ${filepath})
|
||||
if [ ! -d "${filepath_parent}" ]; then
|
||||
echo "Parent directory ${filepath_parent} of ${filepath_child} does not exist - creating"
|
||||
mkdir -p ${filepath_parent}
|
||||
fi
|
||||
;;
|
||||
nuke)
|
||||
rm -f ${filepath}
|
||||
|
||||
@ -102,7 +102,7 @@ namespace dropshell
|
||||
}
|
||||
|
||||
// Create backups directory locally if it doesn't exist
|
||||
std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
std::string local_backups_dir = localpath::backups();
|
||||
if (local_backups_dir.empty())
|
||||
{
|
||||
error << "Error: Local backups directory not found" << std::endl;
|
||||
|
||||
63
source/src/commands/create-server.cpp
Normal file
63
source/src/commands/create-server.cpp
Normal file
@ -0,0 +1,63 @@
|
||||
#include "command_registry.hpp"
|
||||
#include "config.hpp"
|
||||
#include "utils/utils.hpp"
|
||||
#include "utils/directories.hpp"
|
||||
#include "shared_commands.hpp"
|
||||
#include "version.hpp"
|
||||
|
||||
#include <unistd.h>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <filesystem>
|
||||
#include "utils/assert.hpp"
|
||||
|
||||
namespace dropshell {
|
||||
|
||||
void create_server_autocomplete(const CommandContext& ctx);
|
||||
int create_server_handler(const CommandContext& ctx);
|
||||
|
||||
static std::vector<std::string> create_server_name_list={"create-server"};
|
||||
|
||||
// Static registration
|
||||
struct CreateServerCommandRegister {
|
||||
CreateServerCommandRegister() {
|
||||
CommandRegistry::instance().register_command({
|
||||
create_server_name_list,
|
||||
create_server_handler,
|
||||
create_server_autocomplete,
|
||||
false, // hidden
|
||||
true, // requires_config
|
||||
true, // requires_install
|
||||
1, // min_args (after command)
|
||||
1, // max_args (after command)
|
||||
"create-server [SERVER]",
|
||||
"Create a new server entry on this host.",
|
||||
// heredoc
|
||||
R"(
|
||||
Create a new server entry on this host.
|
||||
Note you will need to use ds install SERVER to prepare the service for use.
|
||||
|
||||
create-server SERVER
|
||||
)"
|
||||
});
|
||||
}
|
||||
} create_server_command_register;
|
||||
|
||||
|
||||
void create_server_autocomplete(const CommandContext& ctx) {
|
||||
return; // can't autocomplete as it's a new server!
|
||||
}
|
||||
|
||||
|
||||
int create_server_handler(const CommandContext& ctx) {
|
||||
// create a new server entry on this host
|
||||
if (ctx.args.size() == 0) {
|
||||
error << "No server name provided" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
bool ok = create_server(ctx.args[0]);
|
||||
return ok ? 0 : 1;
|
||||
}
|
||||
|
||||
} // namespace dropshell
|
||||
@ -7,6 +7,8 @@
|
||||
#include "utils/utils.hpp"
|
||||
#include "services.hpp"
|
||||
|
||||
#include <fstream>
|
||||
|
||||
namespace dropshell
|
||||
{
|
||||
|
||||
@ -65,6 +67,39 @@ namespace dropshell
|
||||
namespace shared_commands
|
||||
{
|
||||
|
||||
|
||||
bool print_readme(const template_info &tinfo, std::string server, std::string service)
|
||||
{
|
||||
std::vector<std::string> variants_to_try = {"README.txt", "readme.txt", "ReadMe.txt", "README", "readme", "README.md", "readme.md"};
|
||||
std::filesystem::path readme_path = tinfo.local_template_path();
|
||||
for (const auto &variant : variants_to_try)
|
||||
{
|
||||
if (std::filesystem::exists(readme_path / variant))
|
||||
{
|
||||
readme_path = readme_path / variant;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!std::filesystem::exists(readme_path))
|
||||
return false;
|
||||
|
||||
std::map<std::string, std::string> all_env_vars;
|
||||
get_all_service_env_vars(server, service, all_env_vars);
|
||||
all_env_vars["LOCAL_CONFIG_PATH"] = localpath::service(server, service);
|
||||
all_env_vars["LOCAL_TEMPLATE_PATH"] = tinfo.local_template_path().string();
|
||||
|
||||
info << std::endl;
|
||||
std::ifstream readme_file(readme_path);
|
||||
std::string line;
|
||||
while (std::getline(readme_file, line))
|
||||
{
|
||||
rawout << substitute_provided_key_value_pairs(line, all_env_vars) << std::endl;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name)
|
||||
{
|
||||
if (server_name.empty() || template_name.empty() || service_name.empty())
|
||||
@ -112,10 +147,14 @@ namespace dropshell
|
||||
recursive_copy(tinfo.local_template_path() / "config", service_dir);
|
||||
|
||||
info << "Service " << service_name << " created successfully" << std::endl;
|
||||
info << std::endl;
|
||||
info << "To complete the installation, please:" << std::endl;
|
||||
info << "1. edit the service config file: dropshell edit " << server_name << " " << service_name << std::endl;
|
||||
info << "2. install the remote service: dropshell install " << server_name << " " << service_name << std::endl;
|
||||
|
||||
if (!print_readme(tinfo, server_name, service_name))
|
||||
{
|
||||
info << std::endl;
|
||||
info << "To complete the installation, please:" << std::endl;
|
||||
info << "1. edit the service config file: dropshell edit " << server_name << " " << service_name << std::endl;
|
||||
info << "2. install the remote service: dropshell install " << server_name << " " << service_name << std::endl;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
63
source/src/commands/create-template.cpp
Normal file
63
source/src/commands/create-template.cpp
Normal file
@ -0,0 +1,63 @@
|
||||
#include "command_registry.hpp"
|
||||
#include "config.hpp"
|
||||
#include "utils/utils.hpp"
|
||||
#include "utils/directories.hpp"
|
||||
#include "shared_commands.hpp"
|
||||
#include "version.hpp"
|
||||
#include "utils/assert.hpp"
|
||||
#include "templates.hpp"
|
||||
|
||||
#include <unistd.h>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <filesystem>
|
||||
|
||||
namespace dropshell {
|
||||
|
||||
void create_template_autocomplete(const CommandContext& ctx);
|
||||
int create_template_handler(const CommandContext& ctx);
|
||||
|
||||
static std::vector<std::string> create_template_name_list={"create-template"};
|
||||
|
||||
// Static registration
|
||||
struct CreateTemplateCommandRegister {
|
||||
CreateTemplateCommandRegister() {
|
||||
CommandRegistry::instance().register_command({
|
||||
create_template_name_list,
|
||||
create_template_handler,
|
||||
create_template_autocomplete,
|
||||
false, // hidden
|
||||
true, // requires_config
|
||||
true, // requires_install
|
||||
1, // min_args (after command)
|
||||
1, // max_args (after command)
|
||||
"create-template TEMPLATE",
|
||||
"Create a new template.",
|
||||
// heredoc
|
||||
R"(
|
||||
Create a new template.
|
||||
|
||||
create-template TEMPLATE
|
||||
)"
|
||||
});
|
||||
}
|
||||
} create_template_command_register;
|
||||
|
||||
|
||||
void create_template_autocomplete(const CommandContext& ctx) {
|
||||
return; // can't autocomplete as it's a new server!
|
||||
}
|
||||
|
||||
|
||||
int create_template_handler(const CommandContext& ctx) {
|
||||
// create a new server entry on this host
|
||||
if (ctx.args.size() == 0) {
|
||||
error << "No template name provided" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
bool ok = gTemplateManager().create_template(ctx.args[0]);
|
||||
return ok ? 0 : 1;
|
||||
}
|
||||
|
||||
} // namespace dropshell
|
||||
@ -14,7 +14,7 @@ namespace dropshell
|
||||
{
|
||||
|
||||
int nuke_handler(const CommandContext &ctx);
|
||||
static std::vector<std::string> nuke_name_list = {"nuke"};
|
||||
static std::vector<std::string> nuke_name_list = {"destroy","nuke"};
|
||||
|
||||
// Static registration
|
||||
struct NukeCommandRegister
|
||||
@ -29,15 +29,15 @@ namespace dropshell
|
||||
true, // requires_install
|
||||
2, // min_args (after command)
|
||||
2, // max_args (after command)
|
||||
"nuke SERVER SERVICE|all",
|
||||
"Nuke a service on a server. Destroys everything, both local and remote!",
|
||||
"destroy SERVER SERVICE|all",
|
||||
"Destroy a service on a server. Erases everything, both local and remote!",
|
||||
// heredoc
|
||||
R"(
|
||||
Nuke a service.
|
||||
|
||||
Examples:
|
||||
nuke SERVER SERVICE nuke the given service on the given server.
|
||||
nuke SERVER all nuke all services on the given server.
|
||||
destroy SERVER SERVICE destroy the given service on the given server.
|
||||
destroy SERVER all destroy all services on the given server.
|
||||
|
||||
Note: This command is destructive and will destroy all data and all configuration,
|
||||
both on the dropshell host and on the remote server.
|
||||
@ -45,7 +45,7 @@ struct HelpCommandRegister {
|
||||
|
||||
|
||||
void help_autocomplete(const CommandContext& ctx) {
|
||||
if (ctx.args.size() == 1) {
|
||||
if (ctx.args.size() == 0) {
|
||||
// list all commands
|
||||
for (const auto& cmd : CommandRegistry::instance().list_primary_commands(false)) {
|
||||
rawout << cmd << std::endl;
|
||||
@ -55,6 +55,11 @@ void help_autocomplete(const CommandContext& ctx) {
|
||||
}
|
||||
|
||||
void show_command(const std::string& cmd) {
|
||||
// get console width
|
||||
int width = get_console_width() - 6; // 5 for [INF] + 1 for space
|
||||
int firstcol = 34;
|
||||
int secondcol = width - firstcol - 3;
|
||||
|
||||
const auto& cmd_info = CommandRegistry::instance().find_command(cmd);
|
||||
if (!cmd_info)
|
||||
{
|
||||
@ -62,9 +67,22 @@ void show_command(const std::string& cmd) {
|
||||
return;
|
||||
}
|
||||
|
||||
info << " ";
|
||||
info << left_align(cmd_info->help_usage, 32);
|
||||
info << cmd_info->help_description << std::endl;
|
||||
if (cmd_info->help_usage.length() < width-secondcol)
|
||||
{
|
||||
std::string remaining_description = cmd_info->help_description;
|
||||
|
||||
info << " " << left_align(cmd_info->help_usage, firstcol) << get_line_wrap(remaining_description, secondcol);
|
||||
while (!remaining_description.empty())
|
||||
info << " " << left_align(" ",firstcol) << get_line_wrap(remaining_description, secondcol-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
info << " " << cmd_info->help_usage << std::endl;
|
||||
std::string remaining_description = cmd_info->help_description;
|
||||
info << " " << left_align(" ",firstcol) << get_line_wrap(remaining_description, secondcol);
|
||||
while (!remaining_description.empty())
|
||||
info << " " << left_align(" ",firstcol) << get_line_wrap(remaining_description, secondcol-1);
|
||||
}
|
||||
}
|
||||
|
||||
extern const std::string VERSION;
|
||||
@ -106,7 +124,7 @@ int help_handler(const CommandContext& ctx) {
|
||||
if (ctx.args.size() > 0)
|
||||
return show_command_help(ctx.args[0]);
|
||||
|
||||
info << std::endl;
|
||||
std::cout << std::endl;
|
||||
maketitle("DropShell version " + VERSION);
|
||||
info << std::endl;
|
||||
info << "A tool for managing remote servers, by " << AUTHOR << std::endl;
|
||||
@ -120,16 +138,18 @@ int help_handler(const CommandContext& ctx) {
|
||||
{
|
||||
// show more!
|
||||
show_command("list");
|
||||
std::cout << std::endl;
|
||||
info << std::endl;
|
||||
show_command("install");
|
||||
show_command("uninstall");
|
||||
show_command("nuke");
|
||||
std::cout << std::endl;
|
||||
info << std::endl;
|
||||
show_command("start");
|
||||
show_command("stop");
|
||||
std::cout << std::endl;
|
||||
info << std::endl;
|
||||
show_command("ssh");
|
||||
std::cout << std::endl;
|
||||
info << std::endl;
|
||||
show_command("create-server");
|
||||
show_command("create-service");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
#include "services.hpp"
|
||||
#include "utils/output.hpp"
|
||||
|
||||
#include <fstream>
|
||||
#include <unistd.h>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
@ -39,7 +40,7 @@ namespace dropshell
|
||||
0, // min_args (after command)
|
||||
2, // max_args (after command)
|
||||
"install [SERVER] [SERVICE|all]",
|
||||
"Install/reinstall host, remote servers, or service(s). Safe/non-destructive way to update.",
|
||||
"Install/reinstall host and remote servers, or service(s). Safe way to update.",
|
||||
// heredoc
|
||||
R"(
|
||||
Install components on a server. This is safe to re-run (non-destructive) and used to update
|
||||
@ -55,6 +56,7 @@ namespace dropshell
|
||||
}
|
||||
} install_command_register;
|
||||
|
||||
|
||||
namespace shared_commands
|
||||
{
|
||||
|
||||
@ -132,6 +134,8 @@ namespace dropshell
|
||||
|
||||
// print health tick
|
||||
info << "Health: " << shared_commands::healthtick(server, service) << std::endl;
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -234,30 +238,22 @@ namespace dropshell
|
||||
{
|
||||
maketitle("Installing dropshell agent on this computer...");
|
||||
|
||||
std::vector<std::filesystem::path> paths = {
|
||||
gConfig().get_local_template_cache_path(),
|
||||
gConfig().get_local_backup_path(),
|
||||
gConfig().get_local_tempfiles_path(),
|
||||
localpath::agent()};
|
||||
for (auto &p : gConfig().get_local_server_definition_paths())
|
||||
paths.push_back(p);
|
||||
// clear out old cruft.
|
||||
std::filesystem::remove_all(localpath::agent_local());
|
||||
std::filesystem::remove_all(localpath::agent_remote());
|
||||
|
||||
for (auto &p : paths)
|
||||
if (!std::filesystem::exists(p))
|
||||
{
|
||||
info << "Creating directory: " << p << std::endl;
|
||||
std::filesystem::create_directories(p);
|
||||
}
|
||||
// recreate the directories.
|
||||
localpath::create_directories();
|
||||
|
||||
// create the agent-local directory.
|
||||
recreate_agent_local::recreate_tree(localpath::agent());
|
||||
// populate the agent-local directory.
|
||||
recreate_agent_local::recreate_tree(localpath::agent_local());
|
||||
|
||||
// run the local agent installer.
|
||||
execute_local_command(localpath::agent(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
|
||||
execute_local_command(localpath::agent_local(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
|
||||
|
||||
// create the agent-remote directory.
|
||||
// populate the agent-remote directory.
|
||||
info << "Creating local files to copy to remote agents..." << std::endl;
|
||||
recreate_agent_remote::recreate_tree(localpath::files_for_remote_agent());
|
||||
recreate_agent_remote::recreate_tree(localpath::agent_remote());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -284,7 +280,7 @@ namespace dropshell
|
||||
// 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::files_for_remote_agent(), agent_path, server_env, false);
|
||||
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.
|
||||
|
||||
@ -57,7 +57,7 @@ namespace dropshell
|
||||
|
||||
std::vector<shared_commands::cBackupFileName> get_backup_files(const std::string &server, const std::string &match_service = "", const std::string &match_template_name = "")
|
||||
{
|
||||
std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
std::string local_backups_dir = localpath::backups();
|
||||
if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
|
||||
{
|
||||
error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
|
||||
@ -137,7 +137,7 @@ namespace dropshell
|
||||
debug << " Server: " << server << std::endl;
|
||||
debug << " Service: " << service << std::endl;
|
||||
|
||||
std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
std::string local_backups_dir = localpath::backups();
|
||||
if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
|
||||
{
|
||||
error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
|
||||
|
||||
@ -46,6 +46,15 @@ bool config::load_config() { // load json config file.
|
||||
return true;
|
||||
}
|
||||
|
||||
void _append(std::vector<std::string> & a, const std::vector<std::string> & b) {
|
||||
if (b.empty())
|
||||
return;
|
||||
if (a.empty())
|
||||
a = b;
|
||||
else
|
||||
a.insert(std::end(a), std::begin(b), std::end(b));
|
||||
}
|
||||
|
||||
bool config::save_config(bool create_aux_directories)
|
||||
{
|
||||
std::string config_path = localfile::dropshell_json();
|
||||
@ -61,37 +70,27 @@ bool config::save_config(bool create_aux_directories)
|
||||
if (!mIsConfigSet)
|
||||
{
|
||||
std::string homedir = localpath::current_user_home();
|
||||
std::string dropshell_base = homedir + "/.dropshell";
|
||||
mConfig["tempfiles"] = dropshell_base + "/tmp";
|
||||
mConfig["backups"] = dropshell_base + "/backups";
|
||||
std::string dropshell_base = homedir + "/.local/dropshell_files";
|
||||
|
||||
mConfig["template_cache"] = dropshell_base + "/template_cache";
|
||||
mConfig["template_registry_URLs"] = {
|
||||
"https://templates.dropshell.app"
|
||||
mConfig["server_definition_paths"] = {
|
||||
dropshell_base + "/servers"
|
||||
};
|
||||
mConfig["template_local_paths"] = {
|
||||
dropshell_base + "/local_templates"
|
||||
};
|
||||
|
||||
mConfig["server_definition_paths"] = {
|
||||
dropshell_base + "/servers"
|
||||
};
|
||||
mConfig["template_upload_registry_url"] = "https://templates.dropshell.app";
|
||||
mConfig["template_upload_registry_token"] = "SECRETTOKEN";
|
||||
mConfig["template_registry_URLs"] = {
|
||||
"https://templates.dropshell.app"
|
||||
};
|
||||
mConfig["template_upload_token"] = "SECRETTOKEN";
|
||||
}
|
||||
|
||||
config_file << mConfig.dump(4);
|
||||
config_file.close();
|
||||
|
||||
if (create_aux_directories) {
|
||||
std::vector<std::filesystem::path> paths = {
|
||||
get_local_template_cache_path(),
|
||||
get_local_backup_path(),
|
||||
get_local_tempfiles_path()
|
||||
};
|
||||
for (auto & p : get_local_server_definition_paths())
|
||||
paths.push_back(p);
|
||||
|
||||
std::vector<std::string> paths;
|
||||
_append(paths, get_local_template_paths());
|
||||
_append(paths, get_local_server_definition_paths());
|
||||
for (auto & p : paths)
|
||||
if (!std::filesystem::exists(p))
|
||||
{
|
||||
@ -99,6 +98,11 @@ bool config::save_config(bool create_aux_directories)
|
||||
std::filesystem::create_directories(p);
|
||||
}
|
||||
}
|
||||
|
||||
debug << "Config paths: " << std::endl;
|
||||
for (auto [key,value] : mConfig.items()) {
|
||||
debug << " " << key << ": " << value << std::endl;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -110,31 +114,20 @@ bool config::is_config_set() const
|
||||
|
||||
bool config::is_agent_installed()
|
||||
{
|
||||
return std::filesystem::exists(localpath::agent() + "/bb64");
|
||||
}
|
||||
|
||||
std::string config::get_local_tempfiles_path() {
|
||||
return mConfig["tempfiles"];
|
||||
}
|
||||
|
||||
std::string config::get_local_backup_path() {
|
||||
return mConfig["backups"];
|
||||
}
|
||||
|
||||
std::string config::get_local_template_cache_path() {
|
||||
return mConfig["template_cache"];
|
||||
return std::filesystem::exists(localfile::bb64());
|
||||
}
|
||||
|
||||
std::vector<std::string> config::get_template_registry_urls() {
|
||||
nlohmann::json template_registry_urls = mConfig["template_registry_URLs"];
|
||||
std::vector<std::string> urls;
|
||||
for (auto &url : template_registry_urls) {
|
||||
urls.push_back(url);
|
||||
if (url.is_string() && !url.empty())
|
||||
urls.push_back(url);
|
||||
}
|
||||
return urls;
|
||||
}
|
||||
|
||||
std::vector<std::string> config::get_template_local_paths()
|
||||
std::vector<std::string> config::get_local_template_paths()
|
||||
{
|
||||
nlohmann::json template_local_paths = mConfig["template_local_paths"];
|
||||
std::vector<std::string> paths;
|
||||
@ -147,23 +140,40 @@ std::vector<std::string> config::get_template_local_paths()
|
||||
|
||||
std::vector<std::string> config::get_local_server_definition_paths() {
|
||||
nlohmann::json server_definition_paths = mConfig["server_definition_paths"];
|
||||
|
||||
std::vector<std::string> paths;
|
||||
for (auto &path : server_definition_paths) {
|
||||
if (path.is_string() && !path.empty())
|
||||
paths.push_back(path);
|
||||
else
|
||||
warning << "Invalid server definition path: " << path << std::endl;
|
||||
}
|
||||
return paths;
|
||||
}
|
||||
|
||||
std::string config::get_template_upload_registry_url() {
|
||||
return mConfig["template_upload_registry_url"];
|
||||
std::string config::get_server_create_path()
|
||||
{
|
||||
std::vector<std::string> paths = get_local_server_definition_paths();
|
||||
if (paths.empty())
|
||||
return "";
|
||||
return paths[0];
|
||||
}
|
||||
|
||||
std::string config::get_template_upload_registry_token() {
|
||||
return mConfig["template_upload_registry_token"];
|
||||
std::string config::get_template_create_path()
|
||||
{
|
||||
std::vector<std::string> paths = get_local_template_paths();
|
||||
if (paths.empty())
|
||||
return "";
|
||||
return paths[0];
|
||||
}
|
||||
|
||||
std::string config::get_template_upload_url()
|
||||
{
|
||||
std::vector<std::string> urls = get_template_registry_urls();
|
||||
if (urls.empty())
|
||||
return "";
|
||||
return urls[0];
|
||||
}
|
||||
|
||||
std::string config::get_template_upload_token() {
|
||||
return mConfig["template_upload_token"];
|
||||
}
|
||||
|
||||
} // namespace dropshell
|
||||
@ -17,15 +17,14 @@ class config {
|
||||
bool is_config_set() const;
|
||||
static bool is_agent_installed();
|
||||
|
||||
std::string get_local_tempfiles_path();
|
||||
std::string get_local_backup_path();
|
||||
std::string get_local_template_cache_path();
|
||||
std::vector<std::string> get_template_registry_urls();
|
||||
std::vector<std::string> get_template_local_paths();
|
||||
std::vector<std::string> get_local_template_paths();
|
||||
std::vector<std::string> get_local_server_definition_paths();
|
||||
|
||||
std::string get_template_upload_registry_url();
|
||||
std::string get_template_upload_registry_token();
|
||||
std::string get_server_create_path();
|
||||
std::string get_template_create_path();
|
||||
std::string get_template_upload_url();
|
||||
std::string get_template_upload_token();
|
||||
|
||||
private:
|
||||
nlohmann::json mConfig;
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
#include "config.hpp"
|
||||
#include "templates.hpp"
|
||||
#include "contrib/transwarp.hpp"
|
||||
#include "utils/output.hpp"
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
@ -76,16 +77,16 @@ bool create_server(const std::string &server_name)
|
||||
// 1. check if server name already exists
|
||||
std::string server_existing_dir = localpath::server(server_name);
|
||||
if (!server_existing_dir.empty()) {
|
||||
std::cerr << "Error: Server name already exists: " << server_name << std::endl;
|
||||
std::cerr << "Current server path: " << server_existing_dir << std::endl;
|
||||
error << "Error: Server name already exists: " << server_name << std::endl;
|
||||
info << "Current server path: " << server_existing_dir << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
// 2. create a new directory in the user config directory
|
||||
auto lsdp = gConfig().get_local_server_definition_paths();
|
||||
if (lsdp.empty() || lsdp[0].empty()) {
|
||||
std::cerr << "Error: Local server definition path not found" << std::endl;
|
||||
std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
|
||||
error << "Error: Local server definition path not found" << std::endl;
|
||||
info << "Run 'dropshell edit' to configure DropShell" << std::endl;
|
||||
return false;
|
||||
}
|
||||
std::string server_dir = lsdp[0] + "/" + server_name;
|
||||
@ -93,20 +94,20 @@ bool create_server(const std::string &server_name)
|
||||
|
||||
// 3. create a template server.env file in the server directory
|
||||
std::string user = getenv("USER");
|
||||
std::string server_env_path = server_dir + "/server.env";
|
||||
std::string server_env_path = server_dir + "/server.json";
|
||||
std::ofstream server_env_file(server_env_path);
|
||||
server_env_file << "SSH_HOST=" << server_name << std::endl;
|
||||
server_env_file << "SSH_USER=" << user << std::endl;
|
||||
server_env_file << "SSH_PORT=" << 22 << std::endl;
|
||||
server_env_file << std::endl;
|
||||
server_env_file << "DROPSHELL_DIR=/home/"+user+"/.dropshell" << std::endl;
|
||||
server_env_file << "{" << std::endl;
|
||||
server_env_file << " \"SSH_HOST\": \"" << server_name << "\"," << std::endl;
|
||||
server_env_file << " \"SSH_USER\": \"" << user << "\"," << std::endl;
|
||||
server_env_file << " \"SSH_PORT\": " << 22 << "," << std::endl;
|
||||
server_env_file << " \"DROPSHELL_DIR\": \"" << "/home/"+user+"/.dropshell\"" << std::endl;
|
||||
server_env_file << "}" << std::endl;
|
||||
server_env_file.close();
|
||||
|
||||
std::cout << "Server created successfully: " << server_name << std::endl;
|
||||
std::cout << "Please complete the installation:" <<std::endl;
|
||||
std::cout << "1) edit the server configuration: dropshell edit " << server_name << std::endl;
|
||||
std::cout << "2) test ssh is working: dropshell ssh " << server_name << std::endl;
|
||||
std::cout << "3) install the server: dropshell install " << server_name << std::endl;
|
||||
std::cout << "2) install the server: dropshell install " << server_name << std::endl;
|
||||
std::cout << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1,529 +1,529 @@
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <cstdlib>
|
||||
#include <chrono>
|
||||
#include <iomanip>
|
||||
#include <filesystem>
|
||||
#include <unistd.h>
|
||||
#include "utils/assert.hpp"
|
||||
// #include <iostream>
|
||||
// #include <fstream>
|
||||
// #include <sstream>
|
||||
// #include <cstdlib>
|
||||
// #include <chrono>
|
||||
// #include <iomanip>
|
||||
// #include <filesystem>
|
||||
// #include <unistd.h>
|
||||
// #include "utils/assert.hpp"
|
||||
|
||||
#include "config.hpp"
|
||||
#include "server_env_manager.hpp"
|
||||
#include "templates.hpp"
|
||||
#include "services.hpp"
|
||||
#include "utils/directories.hpp"
|
||||
#include "utils/utils.hpp"
|
||||
#include "command_registry.hpp"
|
||||
#include "shared_commands.hpp"
|
||||
// #include "config.hpp"
|
||||
// #include "server_env_manager.hpp"
|
||||
// #include "templates.hpp"
|
||||
// #include "services.hpp"
|
||||
// #include "utils/directories.hpp"
|
||||
// #include "utils/utils.hpp"
|
||||
// #include "command_registry.hpp"
|
||||
// #include "shared_commands.hpp"
|
||||
|
||||
|
||||
|
||||
|
||||
namespace dropshell {
|
||||
// namespace dropshell {
|
||||
|
||||
|
||||
|
||||
class service_runner {
|
||||
public:
|
||||
service_runner(const std::string& server_name, const std::string& service_name);
|
||||
bool isValid() const { return mValid; }
|
||||
// class service_runner {
|
||||
// public:
|
||||
// service_runner(const std::string& server_name, const std::string& service_name);
|
||||
// bool isValid() const { return mValid; }
|
||||
|
||||
// run a command over ssh, using the credentials from server.env (via server_env.hpp)
|
||||
// first check that the command corresponds to a valid .sh file in the service directory
|
||||
// then run the command, passing the {service_name}.env file as an argument
|
||||
// do a lot of checks, such as:
|
||||
// checking that we can ssh to the server.
|
||||
// checking whether the service directory exists on the server.
|
||||
// checking that the command exists in the service directory.
|
||||
// checking that the command is a valid .sh file.
|
||||
// checking that the {service_name}.env file exists in the service directory.
|
||||
bool run_command(const std::string& command, std::vector<std::string> additional_args={}, std::map<std::string, std::string> env_vars={});
|
||||
// // run a command over ssh, using the credentials from server.env (via server_env.hpp)
|
||||
// // first check that the command corresponds to a valid .sh file in the service directory
|
||||
// // then run the command, passing the {service_name}.env file as an argument
|
||||
// // do a lot of checks, such as:
|
||||
// // checking that we can ssh to the server.
|
||||
// // checking whether the service directory exists on the server.
|
||||
// // checking that the command exists in the service directory.
|
||||
// // checking that the command is a valid .sh file.
|
||||
// // checking that the {service_name}.env file exists in the service directory.
|
||||
// bool run_command(const std::string& command, std::vector<std::string> additional_args={}, std::map<std::string, std::string> env_vars={});
|
||||
|
||||
// check health of service. Silent.
|
||||
// 1. run status.sh on the server
|
||||
// 2. return the output of the status.sh script
|
||||
// // check health of service. Silent.
|
||||
// // 1. run status.sh on the server
|
||||
// // 2. return the output of the status.sh script
|
||||
|
||||
//HealthStatus is_healthy();
|
||||
// //HealthStatus is_healthy();
|
||||
|
||||
// std::string healthtick();
|
||||
// std::string healthmark();
|
||||
// // std::string healthtick();
|
||||
// // std::string healthmark();
|
||||
|
||||
public:
|
||||
// backup and restore
|
||||
bool backup(bool silent=false);
|
||||
bool restore(std::string backup_file, bool silent=false);
|
||||
// public:
|
||||
// // backup and restore
|
||||
// bool backup(bool silent=false);
|
||||
// bool restore(std::string backup_file, bool silent=false);
|
||||
|
||||
// nuke the service
|
||||
bool nuke(bool silent=false); // nukes all data for this service on the remote server
|
||||
bool fullnuke(); // nuke all data for this service on the remote server, and then nukes all the local service definitionfiles
|
||||
// // nuke the service
|
||||
// bool nuke(bool silent=false); // nukes all data for this service on the remote server
|
||||
// bool fullnuke(); // nuke all data for this service on the remote server, and then nukes all the local service definitionfiles
|
||||
|
||||
// launch an interactive ssh session on a server or service
|
||||
// replaces the current dropshell process with the ssh process
|
||||
bool interactive_ssh_service();
|
||||
// // launch an interactive ssh session on a server or service
|
||||
// // replaces the current dropshell process with the ssh process
|
||||
// bool interactive_ssh_service();
|
||||
|
||||
bool scp_file_to_remote(const std::string& local_path, const std::string& remote_path, bool silent=false);
|
||||
bool scp_file_from_remote(const std::string& remote_path, const std::string& local_path, bool silent=false);
|
||||
public:
|
||||
// utility functions
|
||||
static std::string get_latest_backup_file(const std::string& server, const std::string& service);
|
||||
static bool interactive_ssh(const std::string & server_name, const std::string & command);
|
||||
// static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
|
||||
// bool scp_file_to_remote(const std::string& local_path, const std::string& remote_path, bool silent=false);
|
||||
// bool scp_file_from_remote(const std::string& remote_path, const std::string& local_path, bool silent=false);
|
||||
// public:
|
||||
// // utility functions
|
||||
// static std::string get_latest_backup_file(const std::string& server, const std::string& service);
|
||||
// static bool interactive_ssh(const std::string & server_name, const std::string & command);
|
||||
// // static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
|
||||
|
||||
private:
|
||||
std::string mServer;
|
||||
server_env_manager mServerEnv;
|
||||
LocalServiceInfo mServiceInfo;
|
||||
std::string mService;
|
||||
bool mValid;
|
||||
// private:
|
||||
// std::string mServer;
|
||||
// server_env_manager mServerEnv;
|
||||
// LocalServiceInfo mServiceInfo;
|
||||
// std::string mService;
|
||||
// bool mValid;
|
||||
|
||||
// Helper methods
|
||||
public:
|
||||
};
|
||||
// // Helper methods
|
||||
// public:
|
||||
// };
|
||||
|
||||
|
||||
} // namespace dropshell
|
||||
// } // namespace dropshell
|
||||
|
||||
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
// namespace fs = std::filesystem;
|
||||
|
||||
namespace dropshell {
|
||||
// namespace dropshell {
|
||||
|
||||
|
||||
service_runner::service_runner(const std::string& server_name, const std::string& service_name) :
|
||||
mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
|
||||
{
|
||||
if (server_name.empty() || service_name.empty())
|
||||
return;
|
||||
// service_runner::service_runner(const std::string& server_name, const std::string& service_name) :
|
||||
// mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
|
||||
// {
|
||||
// if (server_name.empty() || service_name.empty())
|
||||
// return;
|
||||
|
||||
// Initialize server environment
|
||||
if (!mServerEnv.is_valid())
|
||||
return;
|
||||
// // Initialize server environment
|
||||
// if (!mServerEnv.is_valid())
|
||||
// return;
|
||||
|
||||
mServiceInfo = get_service_info(server_name, service_name);
|
||||
if (mServiceInfo.service_name.empty())
|
||||
return;
|
||||
// mServiceInfo = get_service_info(server_name, service_name);
|
||||
// if (mServiceInfo.service_name.empty())
|
||||
// return;
|
||||
|
||||
mService = mServiceInfo.service_name;
|
||||
// mService = mServiceInfo.service_name;
|
||||
|
||||
mValid = !mServiceInfo.local_template_path.empty();
|
||||
}
|
||||
// mValid = !mServiceInfo.local_template_path.empty();
|
||||
// }
|
||||
|
||||
|
||||
|
||||
bool service_runner::nuke(bool silent)
|
||||
{
|
||||
maketitle("Nuking " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
|
||||
// bool service_runner::nuke(bool silent)
|
||||
// {
|
||||
// maketitle("Nuking " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
|
||||
|
||||
if (!mServerEnv.is_valid()) return false; // should never hit this.
|
||||
// if (!mServerEnv.is_valid()) return false; // should never hit this.
|
||||
|
||||
std::string remote_service_path = remotepath::service(mServer, mService);
|
||||
// std::string remote_service_path = remotepath::service(mServer, mService);
|
||||
|
||||
info << "Service " << mService << " successfully nuked from " << mServer << std::endl;
|
||||
// info << "Service " << mService << " successfully nuked from " << mServer << std::endl;
|
||||
|
||||
if (!silent) {
|
||||
info << "There's nothing left on the remote server." << std::endl;
|
||||
info << "You can remove the local files with:" << std::endl;
|
||||
info << " rm -rf " << localpath::service(mServer,mService) << std::endl;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
// if (!silent) {
|
||||
// info << "There's nothing left on the remote server." << std::endl;
|
||||
// info << "You can remove the local files with:" << std::endl;
|
||||
// info << " rm -rf " << localpath::service(mServer,mService) << std::endl;
|
||||
// }
|
||||
// return true;
|
||||
// }
|
||||
|
||||
bool service_runner::fullnuke()
|
||||
{
|
||||
if (!nuke(true))
|
||||
{
|
||||
warning << "Nuke script failed, aborting." << std::endl;
|
||||
return false;
|
||||
}
|
||||
// bool service_runner::fullnuke()
|
||||
// {
|
||||
// if (!nuke(true))
|
||||
// {
|
||||
// warning << "Nuke script failed, aborting." << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
std::string local_service_path = mServiceInfo.local_service_path;
|
||||
if (local_service_path.empty() || !fs::exists(local_service_path)) {
|
||||
error << "Service directory not found: " << local_service_path << std::endl;
|
||||
return false;
|
||||
}
|
||||
// std::string local_service_path = mServiceInfo.local_service_path;
|
||||
// if (local_service_path.empty() || !fs::exists(local_service_path)) {
|
||||
// error << "Service directory not found: " << local_service_path << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
std::string rm_cmd = "rm -rf " + quote(local_service_path);
|
||||
if (!execute_local_command("", rm_cmd, {}, nullptr, cMode::Silent)) {
|
||||
error << "Failed to remove service directory" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// std::string rm_cmd = "rm -rf " + quote(local_service_path);
|
||||
// if (!execute_local_command("", rm_cmd, {}, nullptr, cMode::Silent)) {
|
||||
// error << "Failed to remove service directory" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
return true;
|
||||
}
|
||||
// return true;
|
||||
// }
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Run a command on the service.
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args, std::map<std::string, std::string> env_vars) {
|
||||
if (!mServerEnv.is_valid()) {
|
||||
std::cerr << "Error: Server service not initialized" << std::endl;
|
||||
return false;
|
||||
}
|
||||
template_info tinfo = gTemplateManager().get_template_info(mServiceInfo.template_name);
|
||||
if (!tinfo.is_set()) {
|
||||
std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // ------------------------------------------------------------------------------------------------
|
||||
// // Run a command on the service.
|
||||
// // ------------------------------------------------------------------------------------------------
|
||||
// bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args, std::map<std::string, std::string> env_vars) {
|
||||
// if (!mServerEnv.is_valid()) {
|
||||
// std::cerr << "Error: Server service not initialized" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// template_info tinfo = gTemplateManager().get_template_info(mServiceInfo.template_name);
|
||||
// if (!tinfo.is_set()) {
|
||||
// std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
if (command == "fullnuke")
|
||||
return fullnuke();
|
||||
// if (command == "fullnuke")
|
||||
// return fullnuke();
|
||||
|
||||
if (command == "nuke")
|
||||
{
|
||||
std::cout << "Nuking " << mService << " (" << mServiceInfo.template_name << ") on " << mServer << std::endl;
|
||||
return nuke();
|
||||
}
|
||||
// if (command == "nuke")
|
||||
// {
|
||||
// std::cout << "Nuking " << mService << " (" << mServiceInfo.template_name << ") on " << mServer << std::endl;
|
||||
// return nuke();
|
||||
// }
|
||||
|
||||
if (!gTemplateManager().template_command_exists(mServiceInfo.template_name, command)) {
|
||||
std::cout << "No command script for " << mServiceInfo.template_name << " : " << command << std::endl;
|
||||
return true; // nothing to run.
|
||||
}
|
||||
// if (!gTemplateManager().template_command_exists(mServiceInfo.template_name, command)) {
|
||||
// std::cout << "No command script for " << mServiceInfo.template_name << " : " << command << std::endl;
|
||||
// return true; // nothing to run.
|
||||
// }
|
||||
|
||||
// install doesn't require anything on the server yet.
|
||||
// if (command == "install")
|
||||
// return install_service(mServer, mService, false);
|
||||
// // install doesn't require anything on the server yet.
|
||||
// // if (command == "install")
|
||||
// // return install_service(mServer, mService, false);
|
||||
|
||||
std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
|
||||
// std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
|
||||
|
||||
// Check if service directory exists
|
||||
if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
|
||||
std::cerr << "Error: Service is not installed: " << mService << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // Check if service directory exists
|
||||
// if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
|
||||
// std::cerr << "Error: Service is not installed: " << mService << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// Check if command script exists
|
||||
if (!mServerEnv.check_remote_file_exists(script_path)) {
|
||||
std::cerr << "Error: Remote command script not found: " << script_path << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // Check if command script exists
|
||||
// if (!mServerEnv.check_remote_file_exists(script_path)) {
|
||||
// std::cerr << "Error: Remote command script not found: " << script_path << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// Check if env file exists
|
||||
if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
|
||||
std::cerr << "Error: Service config file not found: " << remotefile::service_env(mServer, mService) << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // Check if env file exists
|
||||
// if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
|
||||
// std::cerr << "Error: Service config file not found: " << remotefile::service_env(mServer, mService) << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// if (command == "uninstall")
|
||||
// return uninstall();
|
||||
// // if (command == "uninstall")
|
||||
// // return uninstall();
|
||||
|
||||
if (command == "ssh") {
|
||||
interactive_ssh_service();
|
||||
return true;
|
||||
}
|
||||
if (command == "restore") {
|
||||
if (additional_args.size() < 1) {
|
||||
std::cerr << "Error: restore requires a backup file:" << std::endl;
|
||||
std::cerr << "dropshell restore <server> <service> <backup-file>" << std::endl;
|
||||
return false;
|
||||
}
|
||||
return restore(additional_args[0], false);
|
||||
}
|
||||
if (command == "backup") {
|
||||
return backup(false);
|
||||
}
|
||||
// if (command == "ssh") {
|
||||
// interactive_ssh_service();
|
||||
// return true;
|
||||
// }
|
||||
// if (command == "restore") {
|
||||
// if (additional_args.size() < 1) {
|
||||
// std::cerr << "Error: restore requires a backup file:" << std::endl;
|
||||
// std::cerr << "dropshell restore <server> <service> <backup-file>" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// return restore(additional_args[0], false);
|
||||
// }
|
||||
// if (command == "backup") {
|
||||
// return backup(false);
|
||||
// }
|
||||
|
||||
// Run the generic command
|
||||
std::vector<std::string> args; // not passed through yet.
|
||||
return mServerEnv.run_remote_template_command(mService, command, args, false, env_vars);
|
||||
}
|
||||
// // Run the generic command
|
||||
// std::vector<std::string> args; // not passed through yet.
|
||||
// return mServerEnv.run_remote_template_command(mService, command, args, false, env_vars);
|
||||
// }
|
||||
|
||||
|
||||
|
||||
bool service_runner::interactive_ssh(const std::string & server_name, const std::string & command) {
|
||||
std::string serverpath = localpath::server(server_name);
|
||||
if (serverpath.empty()) {
|
||||
std::cerr << "Error: Server not found: " << server_name << std::endl;
|
||||
return false;
|
||||
}
|
||||
// bool service_runner::interactive_ssh(const std::string & server_name, const std::string & command) {
|
||||
// std::string serverpath = localpath::server(server_name);
|
||||
// if (serverpath.empty()) {
|
||||
// std::cerr << "Error: Server not found: " << server_name << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
server_env_manager env(server_name);
|
||||
if (!env.is_valid()) {
|
||||
std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
|
||||
return false;
|
||||
}
|
||||
sCommand scommand("", "bash",{});
|
||||
return execute_ssh_command(env.get_SSH_INFO(), scommand, cMode::Interactive);
|
||||
}
|
||||
// server_env_manager env(server_name);
|
||||
// if (!env.is_valid()) {
|
||||
// std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// sCommand scommand("", "bash",{});
|
||||
// return execute_ssh_command(env.get_SSH_INFO(), scommand, cMode::Interactive);
|
||||
// }
|
||||
|
||||
|
||||
|
||||
bool service_runner::interactive_ssh_service()
|
||||
{
|
||||
std::set<std::string> used_commands = get_used_commands(mServer, mService);
|
||||
if (used_commands.find("ssh") == used_commands.end()) {
|
||||
std::cerr << "Error: "<< mService <<" does not support ssh" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// bool service_runner::interactive_ssh_service()
|
||||
// {
|
||||
// std::set<std::string> used_commands = get_used_commands(mServer, mService);
|
||||
// if (used_commands.find("ssh") == used_commands.end()) {
|
||||
// std::cerr << "Error: "<< mService <<" does not support ssh" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
std::vector<std::string> args; // not passed through yet.
|
||||
return mServerEnv.run_remote_template_command(mService, "ssh", args, false, {});
|
||||
}
|
||||
// std::vector<std::string> args; // not passed through yet.
|
||||
// return mServerEnv.run_remote_template_command(mService, "ssh", args, false, {});
|
||||
// }
|
||||
|
||||
bool service_runner::scp_file_to_remote(const std::string &local_path, const std::string &remote_path, bool silent)
|
||||
{
|
||||
std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
|
||||
return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
|
||||
}
|
||||
// bool service_runner::scp_file_to_remote(const std::string &local_path, const std::string &remote_path, bool silent)
|
||||
// {
|
||||
// std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
|
||||
// return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
|
||||
// }
|
||||
|
||||
bool service_runner::scp_file_from_remote(const std::string &remote_path, const std::string &local_path, bool silent)
|
||||
{
|
||||
std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
|
||||
return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
|
||||
}
|
||||
// bool service_runner::scp_file_from_remote(const std::string &remote_path, const std::string &local_path, bool silent)
|
||||
// {
|
||||
// std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
|
||||
// return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
|
||||
// }
|
||||
|
||||
bool service_runner::restore(std::string backup_file, bool silent)
|
||||
{
|
||||
if (backup_file.empty()) {
|
||||
std::cerr << "Error: not enough arguments. dropshell restore <server> <service> <backup-file>" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// bool service_runner::restore(std::string backup_file, bool silent)
|
||||
// {
|
||||
// if (backup_file.empty()) {
|
||||
// std::cerr << "Error: not enough arguments. dropshell restore <server> <service> <backup-file>" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
// std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
|
||||
if (backup_file == "latest") {
|
||||
// get the latest backup file from the server
|
||||
backup_file = get_latest_backup_file(mServer, mService);
|
||||
}
|
||||
// if (backup_file == "latest") {
|
||||
// // get the latest backup file from the server
|
||||
// backup_file = get_latest_backup_file(mServer, mService);
|
||||
// }
|
||||
|
||||
std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_file).string();
|
||||
// std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_file).string();
|
||||
|
||||
if (! std::filesystem::exists(local_backup_file_path)) {
|
||||
std::cerr << "Error: Backup file not found at " << local_backup_file_path << std::endl;
|
||||
return false;
|
||||
}
|
||||
// if (! std::filesystem::exists(local_backup_file_path)) {
|
||||
// std::cerr << "Error: Backup file not found at " << local_backup_file_path << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// split the backup filename into parts based on the magic string
|
||||
std::vector<std::string> parts = dropshell::split(backup_file, "-_-");
|
||||
if (parts.size() != 4) {
|
||||
std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // split the backup filename into parts based on the magic string
|
||||
// std::vector<std::string> parts = dropshell::split(backup_file, "-_-");
|
||||
// if (parts.size() != 4) {
|
||||
// std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
std::string backup_server_name = parts[0];
|
||||
std::string backup_template_name = parts[1];
|
||||
std::string backup_service_name = parts[2];
|
||||
std::string backup_datetime = parts[3];
|
||||
// std::string backup_server_name = parts[0];
|
||||
// std::string backup_template_name = parts[1];
|
||||
// std::string backup_service_name = parts[2];
|
||||
// std::string backup_datetime = parts[3];
|
||||
|
||||
if (backup_template_name != mServiceInfo.template_name) {
|
||||
std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
|
||||
return false;
|
||||
}
|
||||
// if (backup_template_name != mServiceInfo.template_name) {
|
||||
// std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
std::string nicedate = std::string(backup_datetime).substr(0, 10);
|
||||
// std::string nicedate = std::string(backup_datetime).substr(0, 10);
|
||||
|
||||
std::cout << "Restoring " << nicedate << " backup of " << backup_template_name << " taken from "<<backup_server_name<<", onto "<<mServer<<"/"<<mService<<std::endl;
|
||||
std::cout << std::endl;
|
||||
std::cout << "*** ALL DATA FOR "<<mServer<<"/"<<mService<<" WILL BE OVERWRITTEN! ***"<<std::endl;
|
||||
// std::cout << "Restoring " << nicedate << " backup of " << backup_template_name << " taken from "<<backup_server_name<<", onto "<<mServer<<"/"<<mService<<std::endl;
|
||||
// std::cout << std::endl;
|
||||
// std::cout << "*** ALL DATA FOR "<<mServer<<"/"<<mService<<" WILL BE OVERWRITTEN! ***"<<std::endl;
|
||||
|
||||
// run the restore script
|
||||
std::cout << "OK, here goes..." << std::endl;
|
||||
// // run the restore script
|
||||
// std::cout << "OK, here goes..." << std::endl;
|
||||
|
||||
{ // backup existing service
|
||||
maketitle("1) Backing up old service... ");
|
||||
if (!backup(true)) // silent=true
|
||||
{
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "Error: Backup failed, restore aborted." << std::endl;
|
||||
std::cerr << "You can try using dropshell install "<<mServer<<" "<<mService<<" to install the service afresh." << std::endl;
|
||||
std::cerr << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
|
||||
return false;
|
||||
}
|
||||
std::cout << "Backup complete." << std::endl;
|
||||
}
|
||||
// { // backup existing service
|
||||
// maketitle("1) Backing up old service... ");
|
||||
// if (!backup(true)) // silent=true
|
||||
// {
|
||||
// std::cerr << std::endl;
|
||||
// std::cerr << "Error: Backup failed, restore aborted." << std::endl;
|
||||
// std::cerr << "You can try using dropshell install "<<mServer<<" "<<mService<<" to install the service afresh." << std::endl;
|
||||
// std::cerr << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// std::cout << "Backup complete." << std::endl;
|
||||
// }
|
||||
|
||||
{ // uninstall service, then nuke it.
|
||||
maketitle("2) Uninstalling old service...");
|
||||
// if (!uninstall(true))
|
||||
// return false;
|
||||
// { // uninstall service, then nuke it.
|
||||
// maketitle("2) Uninstalling old service...");
|
||||
// // if (!uninstall(true))
|
||||
// // return false;
|
||||
|
||||
maketitle("3) Nuking old service...");
|
||||
// if (!nuke(true))
|
||||
// return false;
|
||||
}
|
||||
// maketitle("3) Nuking old service...");
|
||||
// // if (!nuke(true))
|
||||
// // return false;
|
||||
// }
|
||||
|
||||
|
||||
{ // restore service from backup
|
||||
maketitle("4) Restoring service data from backup...");
|
||||
std::string remote_backups_dir = remotepath::backups(mServer);
|
||||
std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
|
||||
// { // restore service from backup
|
||||
// maketitle("4) Restoring service data from backup...");
|
||||
// std::string remote_backups_dir = remotepath::backups(mServer);
|
||||
// std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
|
||||
|
||||
// Copy backup file from local to server
|
||||
if (!scp_file_to_remote(local_backup_file_path, remote_backup_file_path, silent)) {
|
||||
std::cerr << "Failed to copy backup file from local to server" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // Copy backup file from local to server
|
||||
// if (!scp_file_to_remote(local_backup_file_path, remote_backup_file_path, silent)) {
|
||||
// std::cerr << "Failed to copy backup file from local to server" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
|
||||
mServerEnv.run_remote_template_command(mService, "restore", {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}});
|
||||
} // dtor of remote_temp_folder will clean up the temp folder on the server
|
||||
// shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
|
||||
// mServerEnv.run_remote_template_command(mService, "restore", {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}});
|
||||
// } // dtor of remote_temp_folder will clean up the temp folder on the server
|
||||
|
||||
|
||||
// { // installing fresh service
|
||||
// maketitle("5) Non-destructive install of fresh service...");
|
||||
// if (!install_service(mServer, mService, true))
|
||||
// return false;
|
||||
// }
|
||||
// // { // installing fresh service
|
||||
// // maketitle("5) Non-destructive install of fresh service...");
|
||||
// // if (!install_service(mServer, mService, true))
|
||||
// // return false;
|
||||
// // }
|
||||
|
||||
bool healthy = false;
|
||||
{// healthcheck the service
|
||||
maketitle("6) Healthchecking service...");
|
||||
std::string green_tick = "\033[32m✓\033[0m";
|
||||
std::string red_cross = "\033[31m✗\033[0m";
|
||||
healthy= (mServerEnv.run_remote_template_command(mService, "status", {}, silent, {}));
|
||||
if (!silent)
|
||||
std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
|
||||
}
|
||||
// bool healthy = false;
|
||||
// {// healthcheck the service
|
||||
// maketitle("6) Healthchecking service...");
|
||||
// std::string green_tick = "\033[32m✓\033[0m";
|
||||
// std::string red_cross = "\033[31m✗\033[0m";
|
||||
// healthy= (mServerEnv.run_remote_template_command(mService, "status", {}, silent, {}));
|
||||
// if (!silent)
|
||||
// std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
|
||||
// }
|
||||
|
||||
return healthy;
|
||||
}
|
||||
// return healthy;
|
||||
// }
|
||||
|
||||
|
||||
// backup the service over ssh, using the credentials from server.env (via server_env.hpp)
|
||||
// 1. run backup.sh on the server
|
||||
// 2. create a backup file with format server-service-datetime.tgz
|
||||
// 3. store it in the server's DROPSHELL_DIR/backups folder
|
||||
// 4. copy it to the local user_dir/backups folder
|
||||
// // backup the service over ssh, using the credentials from server.env (via server_env.hpp)
|
||||
// // 1. run backup.sh on the server
|
||||
// // 2. create a backup file with format server-service-datetime.tgz
|
||||
// // 3. store it in the server's DROPSHELL_DIR/backups folder
|
||||
// // 4. copy it to the local user_dir/backups folder
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Backup the service.
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool service_runner::backup(bool silent) {
|
||||
auto service_info = get_service_info(mServer, mService);
|
||||
if (service_info.local_service_path.empty()) {
|
||||
std::cerr << "Error: Service not found" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
// // ------------------------------------------------------------------------------------------------
|
||||
// // Backup the service.
|
||||
// // ------------------------------------------------------------------------------------------------
|
||||
// bool service_runner::backup(bool silent) {
|
||||
// auto service_info = get_service_info(mServer, mService);
|
||||
// if (service_info.local_service_path.empty()) {
|
||||
// std::cerr << "Error: Service not found" << std::endl;
|
||||
// return 1;
|
||||
// }
|
||||
|
||||
const std::string command = "backup";
|
||||
// const std::string command = "backup";
|
||||
|
||||
if (!gTemplateManager().template_command_exists(service_info.template_name, command)) {
|
||||
std::cout << "No backup script for " << service_info.template_name << std::endl;
|
||||
return true; // nothing to back up.
|
||||
}
|
||||
// if (!gTemplateManager().template_command_exists(service_info.template_name, command)) {
|
||||
// std::cout << "No backup script for " << service_info.template_name << std::endl;
|
||||
// return true; // nothing to back up.
|
||||
// }
|
||||
|
||||
// Check if basic installed stuff is in place.
|
||||
std::string remote_service_template_path = remotepath::service_template(mServer, mService);
|
||||
std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
|
||||
std::string remote_service_config_path = remotepath::service_config(mServer, mService);
|
||||
if (!mServerEnv.check_remote_items_exist({
|
||||
remotepath::service(mServer, mService),
|
||||
remote_command_script_file,
|
||||
remotefile::service_env(mServer, mService)})
|
||||
)
|
||||
{
|
||||
std::cerr << "Error: Required service directories not found on remote server" << std::endl;
|
||||
std::cerr << "Is the service installed?" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // Check if basic installed stuff is in place.
|
||||
// std::string remote_service_template_path = remotepath::service_template(mServer, mService);
|
||||
// std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
|
||||
// std::string remote_service_config_path = remotepath::service_config(mServer, mService);
|
||||
// if (!mServerEnv.check_remote_items_exist({
|
||||
// remotepath::service(mServer, mService),
|
||||
// remote_command_script_file,
|
||||
// remotefile::service_env(mServer, mService)})
|
||||
// )
|
||||
// {
|
||||
// std::cerr << "Error: Required service directories not found on remote server" << std::endl;
|
||||
// std::cerr << "Is the service installed?" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// Create backups directory on server if it doesn't exist
|
||||
std::string remote_backups_dir = remotepath::backups(mServer);
|
||||
if (!silent) std::cout << "Remote backups directory on "<< mServer <<": " << remote_backups_dir << std::endl;
|
||||
std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
|
||||
if (!execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("",mkdir_cmd, {}), cMode::Silent)) {
|
||||
std::cerr << "Failed to create backups directory on server" << std::endl;
|
||||
return false;
|
||||
}
|
||||
// // Create backups directory on server if it doesn't exist
|
||||
// std::string remote_backups_dir = remotepath::backups(mServer);
|
||||
// if (!silent) std::cout << "Remote backups directory on "<< mServer <<": " << remote_backups_dir << std::endl;
|
||||
// std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
|
||||
// if (!execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("",mkdir_cmd, {}), cMode::Silent)) {
|
||||
// std::cerr << "Failed to create backups directory on server" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// Create backups directory locally if it doesn't exist
|
||||
std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
if (local_backups_dir.empty()) {
|
||||
std::cerr << "Error: Local backups directory not found" << std::endl;
|
||||
std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
|
||||
return false;
|
||||
}
|
||||
if (!std::filesystem::exists(local_backups_dir))
|
||||
std::filesystem::create_directories(local_backups_dir);
|
||||
// // Create backups directory locally if it doesn't exist
|
||||
// std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
// if (local_backups_dir.empty()) {
|
||||
// std::cerr << "Error: Local backups directory not found" << std::endl;
|
||||
// std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// if (!std::filesystem::exists(local_backups_dir))
|
||||
// std::filesystem::create_directories(local_backups_dir);
|
||||
|
||||
// Get current datetime for backup filename
|
||||
auto now = std::chrono::system_clock::now();
|
||||
auto time = std::chrono::system_clock::to_time_t(now);
|
||||
std::stringstream datetime;
|
||||
datetime << std::put_time(std::localtime(&time), "%Y-%m-%d_%H-%M-%S");
|
||||
// // Get current datetime for backup filename
|
||||
// auto now = std::chrono::system_clock::now();
|
||||
// auto time = std::chrono::system_clock::to_time_t(now);
|
||||
// std::stringstream datetime;
|
||||
// datetime << std::put_time(std::localtime(&time), "%Y-%m-%d_%H-%M-%S");
|
||||
|
||||
// Construct backup filename
|
||||
shared_commands::cBackupFileName backup_filename_construction(mServer, mService, service_info.template_name);
|
||||
if (!backup_filename_construction.is_valid()) {
|
||||
std::cerr << "Invalid backup filename" << std::endl;
|
||||
return false;
|
||||
}
|
||||
std::string backup_filename = backup_filename_construction.get_filename();
|
||||
std::string remote_backup_file_path = remote_backups_dir + "/" + backup_filename;
|
||||
std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_filename).string();
|
||||
// // Construct backup filename
|
||||
// shared_commands::cBackupFileName backup_filename_construction(mServer, mService, service_info.template_name);
|
||||
// if (!backup_filename_construction.is_valid()) {
|
||||
// std::cerr << "Invalid backup filename" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// std::string backup_filename = backup_filename_construction.get_filename();
|
||||
// std::string remote_backup_file_path = remote_backups_dir + "/" + backup_filename;
|
||||
// std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_filename).string();
|
||||
|
||||
// assert that the backup filename is valid - -_- appears exactly 3 times in local_backup_file_path.
|
||||
ASSERT(3 == count_substring("-_-", local_backup_file_path), "Invalid backup filename");
|
||||
// // assert that the backup filename is valid - -_- appears exactly 3 times in local_backup_file_path.
|
||||
// ASSERT(3 == count_substring("-_-", local_backup_file_path), "Invalid backup filename");
|
||||
|
||||
{ // Run backup script
|
||||
shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
|
||||
if (!mServerEnv.run_remote_template_command(mService, command, {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}})) {
|
||||
std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
|
||||
return false;
|
||||
}
|
||||
// { // Run backup script
|
||||
// shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
|
||||
// if (!mServerEnv.run_remote_template_command(mService, command, {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}})) {
|
||||
// std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// Copy backup file from server to local
|
||||
if (!scp_file_from_remote(remote_backup_file_path, local_backup_file_path, silent)) {
|
||||
std::cerr << "Failed to copy backup file from server" << std::endl;
|
||||
return false;
|
||||
}
|
||||
} // dtor of remote_temp_folder will clean up the temp folder on the server
|
||||
// // Copy backup file from server to local
|
||||
// if (!scp_file_from_remote(remote_backup_file_path, local_backup_file_path, silent)) {
|
||||
// std::cerr << "Failed to copy backup file from server" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
// } // dtor of remote_temp_folder will clean up the temp folder on the server
|
||||
|
||||
if (!silent) {
|
||||
std::cout << "Backup created successfully. Restore with:"<<std::endl;
|
||||
std::cout << " dropshell restore " << mServer << " " << mService << " " << backup_filename << std::endl;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
// if (!silent) {
|
||||
// std::cout << "Backup created successfully. Restore with:"<<std::endl;
|
||||
// std::cout << " dropshell restore " << mServer << " " << mService << " " << backup_filename << std::endl;
|
||||
// }
|
||||
// return true;
|
||||
// }
|
||||
|
||||
// Helper function to get the latest backup file for a given server and service
|
||||
std::string service_runner::get_latest_backup_file(const std::string& server, const std::string& service) {
|
||||
std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir)) {
|
||||
std::cerr << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
|
||||
return "";
|
||||
}
|
||||
// // Helper function to get the latest backup file for a given server and service
|
||||
// std::string service_runner::get_latest_backup_file(const std::string& server, const std::string& service) {
|
||||
// std::string local_backups_dir = gConfig().get_local_backup_path();
|
||||
// if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir)) {
|
||||
// std::cerr << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
|
||||
// return "";
|
||||
// }
|
||||
|
||||
// Get the template name for this service
|
||||
LocalServiceInfo info = get_service_info(server, service);
|
||||
if (info.template_name.empty()) {
|
||||
std::cerr << "Error: Could not determine template name for service: " << service << std::endl;
|
||||
return "";
|
||||
}
|
||||
// // Get the template name for this service
|
||||
// LocalServiceInfo info = get_service_info(server, service);
|
||||
// if (info.template_name.empty()) {
|
||||
// std::cerr << "Error: Could not determine template name for service: " << service << std::endl;
|
||||
// return "";
|
||||
// }
|
||||
|
||||
// Build the expected prefix for backup files
|
||||
std::string prefix = server + "-_-" + info.template_name + "-_-" + service + "-_-";
|
||||
std::string latest_file;
|
||||
std::string latest_datetime;
|
||||
// // Build the expected prefix for backup files
|
||||
// std::string prefix = server + "-_-" + info.template_name + "-_-" + service + "-_-";
|
||||
// std::string latest_file;
|
||||
// std::string latest_datetime;
|
||||
|
||||
std::cout << "Looking for backup files in " << local_backups_dir << std::endl;
|
||||
// std::cout << "Looking for backup files in " << local_backups_dir << std::endl;
|
||||
|
||||
for (const auto& entry : std::filesystem::directory_iterator(local_backups_dir)) {
|
||||
if (!entry.is_regular_file()) continue;
|
||||
std::string filename = entry.path().filename().string();
|
||||
if (filename.rfind(prefix, 0) == 0) { // starts with prefix
|
||||
// Extract the datetime part
|
||||
size_t dt_start = prefix.size();
|
||||
size_t dt_end = filename.find(".tgz", dt_start);
|
||||
if (dt_end == std::string::npos) continue;
|
||||
std::string datetime = filename.substr(dt_start, dt_end - dt_start);
|
||||
std::cout << "Found backup file: " << filename << " with datetime: " << datetime << std::endl;
|
||||
if (datetime > latest_datetime) {
|
||||
latest_datetime = datetime;
|
||||
latest_file = filename;
|
||||
}
|
||||
}
|
||||
}
|
||||
// for (const auto& entry : std::filesystem::directory_iterator(local_backups_dir)) {
|
||||
// if (!entry.is_regular_file()) continue;
|
||||
// std::string filename = entry.path().filename().string();
|
||||
// if (filename.rfind(prefix, 0) == 0) { // starts with prefix
|
||||
// // Extract the datetime part
|
||||
// size_t dt_start = prefix.size();
|
||||
// size_t dt_end = filename.find(".tgz", dt_start);
|
||||
// if (dt_end == std::string::npos) continue;
|
||||
// std::string datetime = filename.substr(dt_start, dt_end - dt_start);
|
||||
// std::cout << "Found backup file: " << filename << " with datetime: " << datetime << std::endl;
|
||||
// if (datetime > latest_datetime) {
|
||||
// latest_datetime = datetime;
|
||||
// latest_file = filename;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
if (latest_file.empty()) {
|
||||
std::cerr << "Error: No backup files found for " << server << ", " << service << std::endl;
|
||||
}
|
||||
// if (latest_file.empty()) {
|
||||
// std::cerr << "Error: No backup files found for " << server << ", " << service << std::endl;
|
||||
// }
|
||||
|
||||
std::cout << "Latest backup file: " << latest_file << std::endl;
|
||||
return latest_file;
|
||||
}
|
||||
// std::cout << "Latest backup file: " << latest_file << std::endl;
|
||||
// return latest_file;
|
||||
// }
|
||||
|
||||
} // namespace dropshell
|
||||
// } // namespace dropshell
|
||||
@ -137,7 +137,7 @@ std::set<std::string> list_backups(const std::string &server_name, const std::st
|
||||
return backups;
|
||||
}
|
||||
|
||||
std::string backups_dir = gConfig().get_local_backup_path();
|
||||
std::string backups_dir = localpath::backups();
|
||||
if (backups_dir.empty())
|
||||
return backups;
|
||||
|
||||
|
||||
@ -185,7 +185,7 @@
|
||||
return false;
|
||||
}
|
||||
|
||||
auto local_template_paths = gConfig().get_template_local_paths();
|
||||
auto local_template_paths = gConfig().get_local_template_paths();
|
||||
if (local_template_paths.empty()) {
|
||||
std::cerr << "Error: No local template paths found" << std::endl;
|
||||
std::cerr << "Run 'dropshell edit' to add one to the DropShell config" << std::endl;
|
||||
@ -252,7 +252,7 @@
|
||||
ASSERT(mSources.empty(), "Template manager already loaded (sources are not empty).");
|
||||
ASSERT(gConfig().is_config_set(), "Config not set.");
|
||||
ASSERT(!mLoaded, "Template manager already loaded.");
|
||||
auto local_template_paths = gConfig().get_template_local_paths();
|
||||
auto local_template_paths = gConfig().get_local_template_paths();
|
||||
if (local_template_paths.empty())
|
||||
return;
|
||||
for (const auto& path : local_template_paths)
|
||||
|
||||
@ -19,11 +19,11 @@ class template_info {
|
||||
template_info() : mIsSet(false) {}
|
||||
template_info(const std::string& template_name, const std::string& location_id, const std::filesystem::path& local_template_path);
|
||||
virtual ~template_info() {}
|
||||
bool is_set() { return mIsSet; }
|
||||
std::string name() { return mTemplateName; }
|
||||
std::string locationID() { return mLocationID; }
|
||||
std::filesystem::path local_template_path() { return mTemplateLocalPath; }
|
||||
bool template_valid() { return mTemplateValid; }
|
||||
bool is_set() const { return mIsSet; }
|
||||
std::string name() const { return mTemplateName; }
|
||||
std::string locationID() const { return mLocationID; }
|
||||
std::filesystem::path local_template_path() const { return mTemplateLocalPath; }
|
||||
bool template_valid() const { return mTemplateValid; }
|
||||
private:
|
||||
std::string mTemplateName;
|
||||
std::string mLocationID;
|
||||
|
||||
@ -41,6 +41,16 @@ namespace localfile {
|
||||
return (servicepath.empty() ? "" : (fs::path(servicepath) / ".template_info.env").string());
|
||||
}
|
||||
|
||||
std::string template_example()
|
||||
{
|
||||
return localpath::agent_local() + "/template_example";
|
||||
}
|
||||
|
||||
std::string bb64()
|
||||
{
|
||||
return localpath::agent_local() + "/bb64";
|
||||
}
|
||||
|
||||
} // namespace localfile
|
||||
|
||||
|
||||
@ -62,16 +72,17 @@ namespace localpath {
|
||||
|
||||
std::string remote_versions(const std::string &server_name, const std::string &service_name)
|
||||
{
|
||||
std::string template_cache_path = gConfig().get_local_template_cache_path();
|
||||
std::string template_cache_path = localpath::template_cache();
|
||||
return ((template_cache_path.empty() || service_name.empty()) ? "" :
|
||||
(template_cache_path+"/remote_versions/"+service_name+".json"));
|
||||
}
|
||||
std::string agent(){
|
||||
return current_user_home() + "/.local/dropshell_agent";
|
||||
}
|
||||
std::string files_for_remote_agent()
|
||||
std::string agent_local()
|
||||
{
|
||||
return agent() + "/files_for_remote_agent";
|
||||
return current_user_home()+"/.local/dropshell_agent/agent-local";
|
||||
}
|
||||
std::string agent_remote()
|
||||
{
|
||||
return current_user_home() + "/.local/dropshell_agent/agent-remote";
|
||||
}
|
||||
std::string current_user_home()
|
||||
{
|
||||
@ -84,6 +95,50 @@ namespace localpath {
|
||||
warning << "Couldn't determine user directory" << std::endl;
|
||||
return std::string();
|
||||
}
|
||||
|
||||
std::string dropshell_files()
|
||||
{
|
||||
return current_user_home() + "/.local/dropshell_files";
|
||||
return std::string();
|
||||
}
|
||||
|
||||
std::string backups()
|
||||
{
|
||||
return dropshell_files() + "/backups";
|
||||
}
|
||||
|
||||
std::string temp_files()
|
||||
{
|
||||
return dropshell_files() + "/temp_files";
|
||||
}
|
||||
|
||||
std::string template_cache()
|
||||
{
|
||||
return dropshell_files() + "template_cache";
|
||||
}
|
||||
|
||||
bool create_directories()
|
||||
{
|
||||
std::vector<std::filesystem::path> paths = {
|
||||
dropshell_files(),
|
||||
agent_local(),
|
||||
agent_remote(),
|
||||
template_cache(),
|
||||
backups(),
|
||||
temp_files()
|
||||
};
|
||||
for (auto &p : gConfig().get_local_server_definition_paths())
|
||||
paths.push_back(p);
|
||||
|
||||
for (auto &p : paths)
|
||||
if (!p.empty() && !std::filesystem::exists(p))
|
||||
{
|
||||
info << "Creating directory: " << p << std::endl;
|
||||
std::filesystem::create_directories(p);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace localpath
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
|
||||
@ -14,10 +14,30 @@ namespace dropshell {
|
||||
// ~/.config/dropshell/dropshell.json
|
||||
|
||||
// ~/.local/dropshell_agent
|
||||
// |-- bb64 (only used locally, as it's for the local machine's architecture!)
|
||||
// |-- files_for_remote_agent
|
||||
// |-- (other agent files, including _allservicesstatus.sh)
|
||||
// |-- agent-local
|
||||
// |-- agent-install.sh
|
||||
// |-- bb64 (only used locally, as it's for the local machine's architecture!)
|
||||
// |-- template_example
|
||||
// |-- agent-remote
|
||||
// |-- (remote agent files, including _allservicesstatus.sh)
|
||||
|
||||
// ~/.local/dropshell_files
|
||||
// |-- backups
|
||||
// |-- katie-_-squashkiwi-_-squashkiwi-test-_-2025-04-28_21-23-59.tgz
|
||||
// |-- temp_files
|
||||
// |-- template_cache
|
||||
// |-- templates
|
||||
// | |-- <template_name>.json
|
||||
// | |-- <template_name>
|
||||
// | |-- (...script files...)
|
||||
// | |-- _default.env
|
||||
// | |-- config
|
||||
// | |-- service.env
|
||||
// | |-- .template_info.env
|
||||
// | |-- (...other service config files...)
|
||||
// |-- remote_versions
|
||||
// | |-- server_name-service_name.json
|
||||
|
||||
// server_definition_path
|
||||
// |-- <server_name>
|
||||
// |-- server.json
|
||||
@ -27,23 +47,7 @@ namespace dropshell {
|
||||
// |-- .template_info.env
|
||||
// |-- (...other config files for specific server&service...)
|
||||
|
||||
// backup path
|
||||
// |-- katie-_-squashkiwi-_-squashkiwi-test-_-2025-04-28_21-23-59.tgz
|
||||
|
||||
// temp files path
|
||||
|
||||
// template cache path
|
||||
// |-- templates
|
||||
// | |-- <template_name>.json
|
||||
// | |-- <template_name>
|
||||
// | |-- (...script files...)
|
||||
// | |-- _default.env
|
||||
// | |-- config
|
||||
// | |-- service.env
|
||||
// | |-- .template_info.env
|
||||
// | |-- (...other service config files...)
|
||||
// |-- remote_versions
|
||||
// | |-- server_name-service_name.json
|
||||
|
||||
namespace localfile {
|
||||
// ~/.config/dropshell/dropshell.json
|
||||
@ -51,6 +55,8 @@ namespace dropshell {
|
||||
std::string server_json(const std::string &server_name);
|
||||
std::string service_env(const std::string &server_name, const std::string &service_name);
|
||||
std::string template_info_env(const std::string &server_name, const std::string &service_name);
|
||||
std::string template_example();
|
||||
std::string bb64();
|
||||
} // namespace localfile
|
||||
|
||||
namespace localpath {
|
||||
@ -59,9 +65,16 @@ namespace dropshell {
|
||||
|
||||
std::string remote_versions(const std::string &server_name, const std::string &service_name);
|
||||
|
||||
std::string agent();
|
||||
std::string files_for_remote_agent();
|
||||
std::string agent_local();
|
||||
std::string agent_remote();
|
||||
std::string current_user_home();
|
||||
|
||||
std::string dropshell_files();
|
||||
std::string backups();
|
||||
std::string temp_files();
|
||||
std::string template_cache();
|
||||
|
||||
bool create_directories();
|
||||
} // namespace local
|
||||
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ namespace dropshell
|
||||
{
|
||||
if (command.get_command_to_run().empty())
|
||||
return false;
|
||||
std::string full_command = command.construct_cmd(localpath::agent()+"/bb64"); // Get the command string
|
||||
std::string full_command = command.construct_cmd(localfile::bb64()); // Get the command string
|
||||
|
||||
pid_t pid = fork();
|
||||
|
||||
@ -130,7 +130,7 @@ namespace dropshell
|
||||
|
||||
std::string full_cmd;
|
||||
if (!hasFlag(mode, cMode::NoBB64))
|
||||
full_cmd = command.construct_cmd(localpath::agent()+"/bb64");
|
||||
full_cmd = command.construct_cmd(localfile::bb64());
|
||||
else
|
||||
full_cmd = command.construct_cmd("");
|
||||
|
||||
|
||||
@ -42,7 +42,7 @@ namespace dropshell
|
||||
std::lock_guard<std::mutex> lock(output_mutex);
|
||||
if (c == EOF)
|
||||
return !EOF;
|
||||
if (at_line_start_ && c != '\n')
|
||||
if (at_line_start_) // && c != '\n')
|
||||
{
|
||||
dest_ << GREY << tag_ << RESET << ' ' << colour_;
|
||||
at_line_start_ = false;
|
||||
|
||||
@ -7,6 +7,8 @@
|
||||
#include <filesystem>
|
||||
#include <regex>
|
||||
#include <random>
|
||||
#include <sys/ioctl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
namespace dropshell {
|
||||
|
||||
@ -286,29 +288,6 @@ std::vector<std::string> split(const std::string& str, const std::string& delimi
|
||||
return tokens;
|
||||
}
|
||||
|
||||
|
||||
std::string replace_with_environment_variables_like_bash(std::string str) {
|
||||
// Combined regex pattern for both ${var} and $var formats
|
||||
std::regex var_pattern("\\$(?:\\{([^}]+)\\}|([a-zA-Z0-9_]+))");
|
||||
std::string result = str;
|
||||
std::smatch match;
|
||||
|
||||
while (std::regex_search(result, match, var_pattern)) {
|
||||
// match[1] will contain capture from ${var} format
|
||||
// match[2] will contain capture from $var format
|
||||
std::string var_name = match[1].matched ? match[1].str() : match[2].str();
|
||||
|
||||
// Get value from system environment variables
|
||||
const char* env_value = std::getenv(var_name.c_str());
|
||||
std::string value = env_value ? env_value : "";
|
||||
|
||||
result = result.replace(match.position(), match.length(), value);
|
||||
}
|
||||
|
||||
// dequote the result
|
||||
return result;
|
||||
}
|
||||
|
||||
std::string random_alphanumeric_string(int length)
|
||||
{
|
||||
static std::mt19937 generator(std::random_device{}());
|
||||
@ -366,5 +345,91 @@ std::string center_align(const std::string & str, int width) {
|
||||
}
|
||||
|
||||
|
||||
std::string replace_with_environment_variables_like_bash(std::string str) {
|
||||
// Combined regex pattern for both ${var} and $var formats
|
||||
std::regex var_pattern("\\$(?:\\{([^}]+)\\}|([a-zA-Z0-9_]+))");
|
||||
std::string result = str;
|
||||
std::smatch match;
|
||||
|
||||
while (std::regex_search(result, match, var_pattern)) {
|
||||
// match[1] will contain capture from ${var} format
|
||||
// match[2] will contain capture from $var format
|
||||
std::string var_name = match[1].matched ? match[1].str() : match[2].str();
|
||||
|
||||
// Get value from system environment variables
|
||||
const char* env_value = std::getenv(var_name.c_str());
|
||||
std::string value = env_value ? env_value : "";
|
||||
|
||||
result = result.replace(match.position(), match.length(), value);
|
||||
}
|
||||
|
||||
// dequote the result
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
std::string substitute_provided_key_value_pairs(std::string str, const std::map<std::string, std::string> &env_vars)
|
||||
{
|
||||
// Combined regex pattern for both ${var} and $var formats
|
||||
std::regex var_pattern("\\$(?:\\{([^}]+)\\}|([a-zA-Z0-9_]+))");
|
||||
std::string result = str;
|
||||
std::smatch match;
|
||||
|
||||
while (std::regex_search(result, match, var_pattern)) {
|
||||
// match[1] will contain capture from ${var} format
|
||||
// match[2] will contain capture from $var format
|
||||
std::string var_name = match[1].matched ? match[1].str() : match[2].str();
|
||||
|
||||
// Get value from environment variables map
|
||||
auto it = env_vars.find(var_name);
|
||||
std::string value = (it != env_vars.end()) ? it->second : "";
|
||||
|
||||
result = result.replace(match.position(), match.length(), value);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int get_console_width()
|
||||
{
|
||||
struct winsize w;
|
||||
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0) {
|
||||
return w.ws_col;
|
||||
}
|
||||
// Fallback to a reasonable default if we can't get the width
|
||||
return 80;
|
||||
}
|
||||
|
||||
std::string remove_return(std::string str)
|
||||
{
|
||||
str.erase(std::remove(str.begin(), str.end(), '\n'), str.end());
|
||||
return str;
|
||||
}
|
||||
|
||||
std::string get_line_wrap(std::string &src, int maxchars)
|
||||
{
|
||||
if (src.empty())
|
||||
return "";
|
||||
|
||||
if (src.length() <= maxchars)
|
||||
{
|
||||
std::string out = src;
|
||||
src.erase();
|
||||
return remove_return(out) + '\n';
|
||||
}
|
||||
|
||||
// find last whitespace up to but not more than maxchars
|
||||
size_t grab_to=maxchars;
|
||||
size_t lastreturn = src.rfind('\n', maxchars);
|
||||
size_t lastspace = src.rfind(' ', maxchars);
|
||||
if (lastreturn != std::string::npos)
|
||||
grab_to = lastreturn;
|
||||
else if (lastspace != std::string::npos)
|
||||
grab_to = lastspace;
|
||||
|
||||
std::string out = src.substr(0, grab_to);
|
||||
src = src.substr(grab_to + 1);
|
||||
return remove_return(out) + '\n';
|
||||
}
|
||||
|
||||
} // namespace dropshell
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
|
||||
#include "output.hpp"
|
||||
|
||||
@ -41,8 +42,6 @@ void ensure_directories_exist(std::vector<std::string> directories);
|
||||
std::vector<int> search(const std::string &pat, const std::string &txt);
|
||||
int count_substring(const std::string &substring, const std::string &text);
|
||||
|
||||
std::string replace_with_environment_variables_like_bash(std::string str);
|
||||
|
||||
std::string random_alphanumeric_string(int length);
|
||||
|
||||
int die(const std::string & msg);
|
||||
@ -53,4 +52,11 @@ std::string left_align(const std::string & str, int width);
|
||||
std::string right_align(const std::string & str, int width);
|
||||
std::string center_align(const std::string & str, int width);
|
||||
|
||||
std::string replace_with_environment_variables_like_bash(std::string str);
|
||||
std::string substitute_provided_key_value_pairs(std::string str, const std::map<std::string, std::string> & env_vars);
|
||||
|
||||
int get_console_width();
|
||||
|
||||
std::string get_line_wrap(std::string & src, int maxchars);
|
||||
|
||||
} // namespace dropshell
|
||||
Reference in New Issue
Block a user