140 lines
5.1 KiB
C++
140 lines
5.1 KiB
C++
#include "command_registry.hpp"
|
|
#include "shared_commands.hpp"
|
|
#include "config.hpp"
|
|
#include "services.hpp"
|
|
#include "server_env_manager.hpp"
|
|
#include "utils/directories.hpp"
|
|
#include "servers.hpp"
|
|
#include "templates.hpp"
|
|
|
|
#include "utils/assert.hpp"
|
|
|
|
#pragma message ("TODO: Fix issues with Nuke below.")
|
|
|
|
namespace dropshell {
|
|
|
|
int nuke_handler(const CommandContext& ctx);
|
|
static std::vector<std::string> nuke_name_list={"nuke"};
|
|
|
|
// Static registration
|
|
struct NukeCommandRegister {
|
|
NukeCommandRegister() {
|
|
CommandRegistry::instance().register_command({
|
|
nuke_name_list,
|
|
nuke_handler,
|
|
std_autocomplete,
|
|
false, // hidden
|
|
true, // requires_config
|
|
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!",
|
|
// heredoc
|
|
R"(
|
|
Nuke a service on a server. Destroys everything, both local and remote!
|
|
nuke SERVER SERVICE nuke the given service on the given server.
|
|
nuke SERVER all nuke all services on the given server.
|
|
)"
|
|
});
|
|
}
|
|
} nuke_command_register;
|
|
|
|
int nuke_one(std::string server, std::string service)
|
|
{
|
|
server_env_manager server_env(server);
|
|
|
|
// step 1 - nuke on remote server.
|
|
if (server_env.is_valid())
|
|
{
|
|
LocalServiceInfo service_info;
|
|
|
|
service_info = get_service_info(server, service);
|
|
if (!SIvalid(service_info))
|
|
std::cerr << "Warning: Invalid service: " << service << std::endl;
|
|
|
|
if (server_env.check_remote_dir_exists(remotepath::service(server, service)))
|
|
{
|
|
// run the nuke script on the remote server if it exists.
|
|
// otherwise just uninstall.
|
|
if (gTemplateManager().template_command_exists(service_info.template_name, "nuke"))
|
|
{
|
|
if (!server_env.run_remote_template_command(service, "nuke", {}, false, {}))
|
|
std::cerr << "Warning: Failed to run nuke script: " << service << std::endl;
|
|
}
|
|
else
|
|
{
|
|
if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
|
|
std::cerr << "Warning: Failed to uninstall service: " << service << std::endl;
|
|
}
|
|
|
|
// Remove the service directory from the server, running in a docker container as root.
|
|
if (server_env.remove_remote_dir(remotepath::service(server, service), true))
|
|
{
|
|
ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
|
|
std::cout << "Remote service directory removed: " << remotepath::service(server, service) << std::endl;
|
|
}
|
|
else
|
|
std::cerr << "Warning: Failed to remove remote service directory" << std::endl;
|
|
}
|
|
else
|
|
std::cerr << "Warning: Service not found on remote server: " << remotepath::service(server, service) << std::endl;
|
|
}
|
|
else
|
|
std::cerr << "Warning: Can't nuke the remote service as the server is invalid: " << server << std::endl;
|
|
|
|
// step 2 - nuke the local service directory.
|
|
std::string local_service_path = localpath::service(server, service);
|
|
if (local_service_path.empty() || !std::filesystem::exists(local_service_path))
|
|
{
|
|
std::cerr << "Warning: Local service directory not found: " << local_service_path << std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto itemsdeleted = std::filesystem::remove_all(local_service_path);
|
|
if (itemsdeleted == 0)
|
|
std::cerr << "Error: Failed to remove local service directory" << std::endl;
|
|
}
|
|
|
|
std::cout << "Nuked service " << service << " on server " << server << std::endl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int nuke_handler(const CommandContext &ctx)
|
|
{
|
|
ASSERT(ctx.args.size() == 2, "Usage: nuke SERVER SERVICE|all (requires 2 args - you supplied " + std::to_string(ctx.args.size()) + ")");
|
|
ASSERT(gConfig().is_config_set(), "No configuration found. Please run 'dropshell config' to set up your configuration.");
|
|
|
|
std::string server = safearg(ctx.args, 0);
|
|
std::string service = safearg(ctx.args, 1);
|
|
|
|
if (service == "all")
|
|
{
|
|
int rval = 0;
|
|
|
|
// iterate through all service folders in the server directory.
|
|
std::string server_path = localpath::server(server);
|
|
if (server_path.empty())
|
|
{
|
|
std::cerr << "Error: Server not found: " << server << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
for (const auto& entry : std::filesystem::directory_iterator(server_path))
|
|
{
|
|
if (entry.is_directory() && entry.path().filename().string().find(".") != 0)
|
|
{
|
|
std::string service_name = entry.path().filename().string();
|
|
rval |= nuke_one(server, service_name);
|
|
}
|
|
}
|
|
return rval;
|
|
}
|
|
else
|
|
{
|
|
return nuke_one(server, service);
|
|
}
|
|
}
|
|
|
|
} // namespace dropshell
|