public/dropshell
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 44 Wiki Activity

Rework backup/restore

Browse Source
This commit is contained in:
Your Name 2025-05-02 23:00:41 +12:00
parent 710a8c762f
commit d1a739cdd0
5 changed files with 264 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
src/main.cpp
View File

@ -8,7 +8,6 @@
#include "utils/utils.hpp" #include "utils/utils.hpp"
#include "utils/readmes.hpp" #include "utils/readmes.hpp"
#include "autocomplete.hpp" #include "autocomplete.hpp"
#include "main_commands.hpp"
#include "utils/hash.hpp" #include "utils/hash.hpp"
#include <filesystem> #include <filesystem>
@ -69,17 +68,55 @@ int die(const std::string & msg) {
return 1; return 1;
} }
bool parseargs(std::string arg2, std::string arg3, std::string & server_name, std::vector<LocalServiceInfo>& servicelist) int init(const std::vector<std::string> &args)
{ {
if (arg2.empty()) return false; std::string lcd;
server_name = arg2;
if (arg3.empty()) { if (args.size() < 3) {
servicelist = get_server_services_info(server_name); std::cerr << "Error: init command requires a directory argument" << std::endl;
} else { return 1;
servicelist.push_back(get_service_info(server_name, arg3)); }
try {
if (!gConfig().add_local_config_directory(args[2]))
return 1; // error already reported
gConfig().save_config();
std::cout << "Config directory added: " << gConfig().get_local_config_directories().back() << std::endl;
dropshell::create_readme_local_config_dir(gConfig().get_local_config_directories().back());
if (gConfig().get_local_config_directories().size() ==1)
std::cout << "DropShell is now initialised and you can add a server with 'dropshell create-server <server-name>'" << std::endl;
else
{
std::cout << "DropShell will now use all of the following directories for configuration:" << std::endl;
for (const auto& dir : gConfig().get_local_config_directories()) {
std::cout << " " << dir << std::endl;
}
std::cout << "You can edit the config file manually with: dropshell edit" << std::endl;
}
} catch (const std::exception& e) {
std::cerr << "Error in init: " << e.what() << std::endl;
return 1;
}
return 0;
} }
struct ServerAndServices {
std::string server_name;
std::vector<LocalServiceInfo> servicelist;
};
bool getCLIServices(const std::string & arg2, const std::string & arg3,
ServerAndServices & server_and_services)
{
if (arg2.empty()) return false;
server_and_services.server_name = arg2;
if (arg3.empty()) {
server_and_services.servicelist = get_server_services_info(arg2);
} else {
server_and_services.servicelist.push_back(get_service_info(arg2, arg3));
}
return true; return true;
} }
@ -126,7 +163,7 @@ int main(int argc, char* argv[]) {
} }
if (cmd == "init") { if (cmd == "init") {
return main_commands::init(argvec); return init(argvec);
} }
if (cmd == "help" || cmd == "-h" || cmd == "--help" || cmd== "h" || cmd=="halp") { if (cmd == "help" || cmd == "-h" || cmd == "--help" || cmd== "h" || cmd=="halp") {
@ -203,36 +240,28 @@ int main(int argc, char* argv[]) {
return 0; return 0;
} }
if (cmd == "backup" || cmd=="backups") {
if (argc < 4) return die("Error: backup requires a target server and target service to back up");
return main_commands::backup(argvec);
}
if (cmd == "restore") {
if (argc < 4) return die("Error: restore requires a target server, target service the backup file to restore");
return main_commands::restore(argvec);
}
// handle running a command. // handle running a command.
std::set<std::string> commands; std::set<std::string> commands;
get_all_used_commands(commands); get_all_used_commands(commands);
commands.merge(std::set<std::string>{"ssh","edit","_allservicesstatus"}); // handled by service_runner, but not in template_shell_commands. commands.merge(std::set<std::string>{"ssh","edit","_allservicesstatus"}); // handled by service_runner, but not in template_shell_commands.
for (const auto& command : commands) { for (const auto& command : commands) {
if (cmd == command) { if (cmd == command) {
std::string server_name; ServerAndServices server_and_services;
std::vector<LocalServiceInfo> servicelist; if (!getCLIServices(safearg(argc, argv, 2), safearg(argc, argv, 3), server_and_services)) {
if (!parseargs(safearg(argc, argv, 2), safearg(argc, argv, 3), server_name, servicelist)) {
std::cerr << "Error: " << command << " command requires server name and optionally service name" << std::endl; std::cerr << "Error: " << command << " command requires server name and optionally service name" << std::endl;
return 1; return 1;
} }
for (const auto& service_info : servicelist) { for (const auto& service_info : server_and_services.servicelist) {
service_runner runner(server_name, service_info.service_name); service_runner runner(server_and_services.server_name, service_info.service_name);
if (!runner.isValid()) { if (!runner.isValid()) {
std::cerr << "Error: Failed to initialize service" << std::endl; std::cerr << "Error: Failed to initialize service" << std::endl;
return 1; return 1;
} }
if (!runner.run_command(command)) { std::vector<std::string> additional_args;
for (int i=4; i<argc; i++)
additional_args.push_back(argv[i]);
if (!runner.run_command(command, additional_args)) {
std::cerr << command +" failed." << std::endl; std::cerr << command +" failed." << std::endl;
return 1; return 1;
} }

280
src/main_commands.cpp
View File

@ -1,280 +0,0 @@
#include "main_commands.hpp"
#include "utils/directories.hpp"
#include "utils/utils.hpp"
#include "utils/readmes.hpp"
#include "service_runner.hpp"
#include "config.hpp"
#include "templates.hpp"
#include "server_env_manager.hpp"
#include <iostream>
#include <filesystem>
#include <algorithm>
namespace dropshell {
namespace main_commands {
static const std::string magic_string = "-_-";
int init(const std::vector<std::string> &args)
{
std::string lcd;
if (args.size() < 3) {
std::cerr << "Error: init command requires a directory argument" << std::endl;
return 1;
}
try {
if (!gConfig().add_local_config_directory(args[2]))
return 1; // error already reported
gConfig().save_config();
std::cout << "Config directory added: " << gConfig().get_local_config_directories().back() << std::endl;
dropshell::create_readme_local_config_dir(gConfig().get_local_config_directories().back());
if (gConfig().get_local_config_directories().size() ==1)
std::cout << "DropShell is now initialised and you can add a server with 'dropshell create-server <server-name>'" << std::endl;
else
{
std::cout << "DropShell will now use all of the following directories for configuration:" << std::endl;
for (const auto& dir : gConfig().get_local_config_directories()) {
std::cout << " " << dir << std::endl;
}
std::cout << "You can edit the config file manually with: dropshell edit" << std::endl;
}
} catch (const std::exception& e) {
std::cerr << "Error in init: " << e.what() << std::endl;
return 1;
}
return 0;
}
int restore(const std::vector<std::string> &args, bool silent)
{
if (args.size() < 4) {
std::cerr << "Error: not enough arguments. dropshell restore <server> <service> <backup-file>" << std::endl;
return 1;
}
std::string server_name = args[2];
std::string service_name = args[3];
std::string backup_file = args[4];
auto service_info = get_service_info(server_name, service_name);
if (service_info.local_service_path.empty()) {
std::cerr << "Error: Service not found" << std::endl;
return 1;
}
server_env_manager env(server_name);
if (!env.is_valid()) {
std::cerr << "Error: Invalid server environment" << std::endl;
return 1;
}
std::string local_backups_dir = localpath::backups_path();
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 1;
}
// split the backup filename into parts based on the magic string
std::vector<std::string> parts = dropshell::split(backup_file, magic_string);
if (parts.size() != 4) {
std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
return 1;
}
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 != service_info.template_name) {
std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
return 1;
}
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 "<<server_name<<std::endl;
std::cout << std::endl;
std::cout << "*** ALL DATA FOR "<<server_name<<"/"<<service_name<<" WILL BE OVERWRITTEN! ***"<<std::endl;
std::cout << std::endl;
std::cout << "Are you sure you want to continue? (y/n)" << std::endl;
char confirm;
std::cin >> confirm;
if (confirm != 'y') {
std::cout << "Restore cancelled." << std::endl;
return 1;
}
// run the restore script
std::cout << "OK, here goes..." << std::endl;
{ // backup existing service
std::cout << "1) Backing up existing service... " << std::flush;
std::vector<std::string> backup_args = {"dropshell","backup",server_name, service_name};
if (!backup(backup_args,true)) // silent=true
{
std::cerr << std::endl;
std::cerr << "Error: Backup failed, restore aborted." << std::endl;
std::cerr << "You can try using dropshell install "<<server_name<<" "<<service_name<<" 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 1;
}
std::cout << "Backup complete." << std::endl;
}
{ // restore service from backup
std::cout << "2) Restoring service from backup..." << std::endl;
std::string remote_backups_dir = remotepath::backups(server_name);
std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
// Copy backup file from local to server
std::string scp_cmd = "scp -P " + env.get_SSH_PORT() + " " + quote(local_backup_file_path) + " " + env.get_SSH_USER() + "@" + env.get_SSH_HOST() + ":" + quote(remote_backup_file_path) + (silent ? " > /dev/null 2>&1" : "");
if (!env.execute_local_command(scp_cmd)) {
std::cerr << "Failed to copy backup file from server" << std::endl;
return false;
}
env.run_remote_template_command(service_name, "restore", {remote_backup_file_path}, silent);
}
// healthcheck the service
std::cout << "3) Healthchecking service..." << std::endl;
std::string green_tick = "\033[32m✓\033[0m";
std::string red_cross = "\033[31m✗\033[0m";
bool healthy= (env.run_remote_template_command(service_name, "status", {}, silent));
if (!silent)
std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
return 0;
}
bool name_breaks_backups(std::string name)
{
// if name contains -_-, return true
return name.find("-_-") != std::string::npos;
}
// 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.
// ------------------------------------------------------------------------------------------------
int backup(const std::vector<std::string> & args, bool silent) {
if (args.size() < 4) {
std::cerr << "Error: backup command requires a server name and service name" << std::endl;
return 1;
}
std::string server_name = args[2];
std::string service_name = args[3];
auto service_info = get_service_info(server_name, service_name);
if (service_info.local_service_path.empty()) {
std::cerr << "Error: Service not found" << std::endl;
return 1;
}
server_env_manager env(server_name);
if (!env.is_valid()) {
std::cerr << "Error: Invalid server environment" << std::endl;
return 1;
}
const std::string command = "backup";
if (!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(server_name, service_name);
std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
std::string remote_service_config_path = remotepath::service_config(server_name, service_name);
if (!env.check_remote_items_exist({
remotepath::service(server_name, service_name),
remote_command_script_file,
remotefile::service_env(server_name, service_name)})
)
{
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(server_name);
if (!silent) std::cout << "Remote backups directory on "<< server_name <<": " << remote_backups_dir << std::endl;
std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
if (!env.execute_ssh_command(mkdir_cmd)) {
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 = localpath::backups_path();
if (local_backups_dir.empty()) {
std::cerr << "Error: Local backups directory not found - is DropShell initialised?" << 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");
if (name_breaks_backups(server_name)) {std::cerr << "Error: Server name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
if (name_breaks_backups(service_name)) {std::cerr << "Error: Service name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
if (name_breaks_backups(service_info.template_name)) {std::cerr << "Error: Service template name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
// Construct backup filename
std::string backup_filename = server_name + magic_string + service_info.template_name + magic_string + service_name + magic_string + datetime.str() + ".tgz";
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(magic_string, local_backup_file_path));
// Run backup script
if (!env.run_remote_template_command(service_name, command, {remote_backup_file_path}, silent)) {
std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
return false;
}
// Copy backup file from server to local
std::string scp_cmd = "scp -P " + env.get_SSH_PORT() + " " +
env.get_SSH_USER() + "@" + env.get_SSH_HOST() + ":" +
quote(remote_backup_file_path) + " " + quote(local_backup_file_path) + (silent ? " > /dev/null 2>&1" : "");
if (!env.execute_local_command(scp_cmd)) {
std::cerr << "Failed to copy backup file from server" << std::endl;
return false;
}
if (!silent) {
std::cout << "Backup created successfully. Restore with:"<<std::endl;
std::cout << " dropshell restore " << server_name << " " << service_name << " " << backup_filename << std::endl;
}
return true;
}
} // namespace main_commands
} // namespace dropshell

18
src/main_commands.hpp
View File

@ -1,18 +0,0 @@
#ifndef MAIN_COMMANDS_HPP
#define MAIN_COMMANDS_HPP
#include <string>
#include <vector>
namespace dropshell {
namespace main_commands {
int init(const std::vector<std::string> &args);
int restore(const std::vector<std::string> &args, bool silent=false);
int backup(const std::vector<std::string> &args, bool silent=false);
} // namespace main_commands
} // namespace dropshell
#endif

225
src/service_runner.cpp
View File

@ -18,6 +18,8 @@ namespace fs = std::filesystem;
namespace dropshell { namespace dropshell {
static const std::string magic_string = "-_-";
service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 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) mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
{ {
@ -146,7 +148,7 @@ bool service_runner::uninstall() {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Run a command on the service. // Run a command on the service.
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
bool service_runner::run_command(const std::string& command) { bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args) {
if (!mServerEnv.is_valid()) { if (!mServerEnv.is_valid()) {
std::cerr << "Error: Server service not initialized" << std::endl; std::cerr << "Error: Server service not initialized" << std::endl;
return false; return false;
@ -195,6 +197,17 @@ bool service_runner::run_command(const std::string& command) {
interactive_ssh_service(); interactive_ssh_service();
return true; 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 // Run the generic command
std::vector<std::string> args; // not passed through yet. std::vector<std::string> args; // not passed through yet.
@ -404,23 +417,6 @@ void edit_file(const std::string &file_path, const std::string & aftertext)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
bool service_runner::restore(std::string backup_file)
{
std::string command = "restore";
std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
if (!template_command_exists(mServiceInfo.template_name, command)) {
std::cout << "No restore script for " << mServiceInfo.template_name << std::endl;
return true; // nothing to restore.
}
/// TOODOOOOOO!!!!!!
std::cout << "Restore not implemented yet" << std::endl;
return true;
// std::string run_cmd = construct_standard_command_run_cmd("restore");
// return execute_ssh_command(run_cmd, "Restore script failed");
}
void service_runner::interactive_ssh_service() void service_runner::interactive_ssh_service()
{ {
std::set<std::string> used_commands = get_used_commands(mServer, mService); std::set<std::string> used_commands = get_used_commands(mServer, mService);
@ -446,4 +442,197 @@ void service_runner::edit_service_config()
edit_file(config_file, aftertext); edit_file(config_file, aftertext);
} }
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 = localpath::backups_path();
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;
}
// split the backup filename into parts based on the magic string
std::vector<std::string> parts = dropshell::split(backup_file, magic_string);
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];
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::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 << std::endl;
std::cout << "Are you sure you want to continue? (y/n)" << std::endl;
char confirm;
std::cin >> confirm;
if (confirm != 'y') {
std::cout << "Restore cancelled." << std::endl;
return false;
}
// run the restore script
std::cout << "OK, here goes..." << std::endl;
{ // backup existing service
std::cout << "1) Backing up existing service... " << std::flush;
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;
}
{ // restore service from backup
std::cout << "2) Restoring service from backup..." << std::endl;
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
std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_backup_file_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_backup_file_path) + (silent ? " > /dev/null 2>&1" : "");
if (!mServerEnv.execute_local_command(scp_cmd)) {
std::cerr << "Failed to copy backup file from server" << std::endl;
return false;
}
mServerEnv.run_remote_template_command(mService, "restore", {remote_backup_file_path}, silent);
}
// healthcheck the service
std::cout << "3) Healthchecking service..." << std::endl;
std::string green_tick = "\033[32m✓\033[0m";
std::string red_cross = "\033[31m✗\033[0m";
bool 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 true;
}
bool name_breaks_backups(std::string name)
{
// if name contains -_-, return true
return name.find("-_-") != std::string::npos;
}
// 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;
}
const std::string command = "backup";
if (!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;
}
// 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 (!mServerEnv.execute_ssh_command(mkdir_cmd)) {
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 = localpath::backups_path();
if (local_backups_dir.empty()) {
std::cerr << "Error: Local backups directory not found - is DropShell initialised?" << 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");
if (name_breaks_backups(mServer)) {std::cerr << "Error: Server name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
if (name_breaks_backups(mService)) {std::cerr << "Error: Service name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
if (name_breaks_backups(service_info.template_name)) {std::cerr << "Error: Service template name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
// Construct backup filename
std::string backup_filename = mServer + magic_string + service_info.template_name + magic_string + mService + magic_string + datetime.str() + ".tgz";
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(magic_string, local_backup_file_path));
// Run backup script
if (!mServerEnv.run_remote_template_command(mService, command, {remote_backup_file_path}, silent)) {
std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
return false;
}
// Copy backup file from server to local
std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " +
mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" +
quote(remote_backup_file_path) + " " + quote(local_backup_file_path) + (silent ? " > /dev/null 2>&1" : "");
if (!mServerEnv.execute_local_command(scp_cmd)) {
std::cerr << "Failed to copy backup file from server" << std::endl;
return false;
}
if (!silent) {
std::cout << "Backup created successfully. Restore with:"<<std::endl;
std::cout << " dropshell restore " << mServer << " " << mService << " " << backup_filename << std::endl;
}
return true;
}
} // namespace dropshell } // namespace dropshell

10
src/service_runner.hpp
View File

@ -30,6 +30,7 @@ typedef struct ServiceStatus {
std::vector<int> ports; std::vector<int> ports;
} ServiceStatus; } ServiceStatus;
class service_runner { class service_runner {
public: public:
service_runner(const std::string& server_name, const std::string& service_name); service_runner(const std::string& server_name, const std::string& service_name);
@ -44,7 +45,7 @@ class service_runner {
// checking that the command exists in the service directory. // checking that the command exists in the service directory.
// checking that the command is a valid .sh file. // checking that the command is a valid .sh file.
// checking that the {service_name}.env file exists in the service directory. // checking that the {service_name}.env file exists in the service directory.
bool run_command(const std::string& command); bool run_command(const std::string& command, std::vector<std::string> additional_args={});
// check health of service. Silent. // check health of service. Silent.
// 1. run status.sh on the server // 1. run status.sh on the server
@ -79,10 +80,9 @@ class service_runner {
// 4. remove the service directory from the server // 4. remove the service directory from the server
bool uninstall(); bool uninstall();
// restore the service over ssh, using the credentials from server.env (via server_env.hpp) // backup and restore
// 1. copy the backup file to the server's DROPSHELL_DIR/backups folder bool backup(bool silent=false);
// 2. run the restore.sh script on the server, passing the {service_name}.env file as an argument bool restore(std::string backup_file, bool silent=false);
bool restore(std::string backup_file);
// launch an interactive ssh session on a server or service // launch an interactive ssh session on a server or service
// replaces the current dropshell process with the ssh process // replaces the current dropshell process with the ssh process