259 lines
9.8 KiB
C++
259 lines
9.8 KiB
C++
#include <filesystem>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <iomanip>
|
|
#include <map>
|
|
|
|
#include "utils/envmanager.hpp"
|
|
#include "utils/directories.hpp"
|
|
#include "utils/utils.hpp"
|
|
#include "templates.hpp"
|
|
#include "config.hpp"
|
|
|
|
namespace dropshell {
|
|
|
|
|
|
bool get_templates(std::vector<template_info>& templates) {
|
|
templates.clear();
|
|
|
|
// Helper function to add templates from a directory
|
|
auto add_templates_from_dir = [&templates](const std::string& dir_path) {
|
|
if (!std::filesystem::exists(dir_path))
|
|
return;
|
|
|
|
for (const auto& entry : std::filesystem::directory_iterator(dir_path))
|
|
if (entry.is_directory()) {
|
|
|
|
template_info info(entry.path().filename().string(), entry.path().string());
|
|
|
|
// Check if template with same name already exists
|
|
bool duplicate = false;
|
|
auto it = std::find_if(templates.begin(), templates.end(),
|
|
[&info](const template_info& t) { return t.template_name == info.template_name; });
|
|
duplicate = (it!=templates.end());
|
|
|
|
if (!duplicate)
|
|
templates.push_back(info);
|
|
}
|
|
};
|
|
|
|
// add templates from the local config directories
|
|
std::vector<std::string> template_config_directories;
|
|
get_all_template_config_directories(template_config_directories);
|
|
for (const auto& path : template_config_directories) {
|
|
add_templates_from_dir(path);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool get_template_info(const std::string& template_name, template_info& info) {
|
|
// add templates from the local config directories
|
|
std::vector<std::string> paths_to_search;
|
|
get_all_template_config_directories(paths_to_search);
|
|
|
|
for (const auto& path : paths_to_search) {
|
|
std::filesystem::path full_path = path + "/" + template_name;
|
|
if (std::filesystem::exists(full_path))
|
|
{
|
|
info.template_name = template_name;
|
|
info.local_template_path = full_path.string();
|
|
return true;
|
|
}
|
|
}
|
|
std::cout << "Warning: Template '" << template_name << "' not found" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
bool template_command_exists(const std::string &template_name, const std::string &command)
|
|
{
|
|
template_info info;
|
|
if (!get_template_info(template_name, info)) {
|
|
return false;
|
|
}
|
|
|
|
std::string path = info.local_template_path + "/" + command + ".sh";
|
|
return (std::filesystem::exists(path));
|
|
}
|
|
|
|
void list_templates() {
|
|
std::vector<template_info> templates;
|
|
|
|
if (!get_templates(templates)) {
|
|
std::cerr << "Error: Failed to get templates" << std::endl;
|
|
return;
|
|
}
|
|
|
|
if (templates.empty()) {
|
|
std::cout << "No templates found." << std::endl;
|
|
return;
|
|
}
|
|
|
|
std::cout << "Available templates:" << std::endl;
|
|
std::cout << std::left << std::setw(20) << "Name" << "Path" << std::endl;
|
|
std::cout << std::string(60, '-') << std::endl;
|
|
|
|
for (const auto& t : templates) {
|
|
std::cout << std::left << std::setw(20) << t.template_name << t.local_template_path << std::endl;
|
|
}
|
|
}
|
|
|
|
void create_template(const std::string& template_name) {
|
|
// 1. Create a new directory in the user templates directory
|
|
std::vector<std::string> local_config_directories = gConfig().get_local_config_directories();
|
|
|
|
if (local_config_directories.empty()) {
|
|
std::cerr << "Error: No local config directories found" << std::endl;
|
|
std::cerr << "Run 'dropshell init' to initialise DropShell" << std::endl;
|
|
return;
|
|
}
|
|
|
|
template_info info;
|
|
if (get_template_info(template_name, info)) {
|
|
std::cerr << "Error: Template '" << template_name << "' already exists at " << info.local_template_path << std::endl;
|
|
return;
|
|
}
|
|
|
|
std::string new_template_path = localpath::config_templates() + "/" + template_name;
|
|
|
|
// Create the new template directory
|
|
std::filesystem::create_directories(new_template_path);
|
|
|
|
// 2. Copy the example template from the system templates directory
|
|
std::string system_templates_dir = localpath::system_templates();
|
|
std::string example_template_path = system_templates_dir + "/example-nginx";
|
|
|
|
if (!std::filesystem::exists(example_template_path)) {
|
|
std::cerr << "Error: Example template not found at " << example_template_path << std::endl;
|
|
return;
|
|
}
|
|
|
|
// Copy all files from example template to new template
|
|
for (const auto& entry : std::filesystem::recursive_directory_iterator(example_template_path)) {
|
|
std::string relative_path = entry.path().string().substr(example_template_path.length());
|
|
std::string target_path = new_template_path + relative_path;
|
|
|
|
if (entry.is_directory()) {
|
|
std::filesystem::create_directory(target_path);
|
|
} else {
|
|
std::filesystem::copy_file(entry.path(), target_path);
|
|
}
|
|
}
|
|
|
|
// modify the TEMPLATE=example line in the service.env file to TEMPLATE=<template_name>
|
|
std::string search_string = "TEMPLATE=";
|
|
std::string replacement_line = "TEMPLATE=" + template_name;
|
|
// replace the line in the example/service.env file with the replacement line
|
|
std::string service_env_path = new_template_path + "/example/service.env";
|
|
if (!replace_line_in_file(service_env_path, search_string, replacement_line)) {
|
|
std::cerr << "Error: Failed to replace TEMPLATE= line in service.env file" << std::endl;
|
|
return;
|
|
}
|
|
|
|
// 3. Print out the README.txt file and the path
|
|
std::string readme_path = new_template_path + "/README.txt";
|
|
if (std::filesystem::exists(readme_path)) {
|
|
std::cout << "\nREADME contents:" << std::endl;
|
|
std::cout << std::string(60, '-') << std::endl;
|
|
|
|
std::ifstream readme_file(readme_path);
|
|
if (readme_file.is_open()) {
|
|
std::string line;
|
|
while (std::getline(readme_file, line)) {
|
|
std::cout << line << std::endl;
|
|
}
|
|
readme_file.close();
|
|
}
|
|
std::cout << std::string(60, '-') << std::endl;
|
|
} else {
|
|
std::cout << "No README.txt file found in the template." << std::endl;
|
|
}
|
|
|
|
std::cout << std::endl;
|
|
std::cout << "Template '" << template_name << "' created at " << new_template_path << std::endl;
|
|
}
|
|
|
|
bool get_all_template_config_directories(std::vector<std::string> &template_config_directories)
|
|
{
|
|
template_config_directories.clear();
|
|
for (int i = 0; i < localpath::num_config_directories(); i++) {
|
|
std::string config_templates_path = localpath::config_templates(i);
|
|
if (config_templates_path.empty()) {
|
|
std::cerr << "Error: Templates directory not found: " << config_templates_path << std::endl;
|
|
return false;
|
|
}
|
|
template_config_directories.push_back(config_templates_path);
|
|
}
|
|
template_config_directories.push_back(localpath::system_templates());
|
|
return true;
|
|
}
|
|
|
|
bool required_file(std::string path, std::string template_name)
|
|
{
|
|
if (!std::filesystem::exists(path)) {
|
|
std::cerr << "Error: " << path << " file not found in template " << template_name << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool test_template(const std::string &template_path)
|
|
{
|
|
std::string template_name = std::filesystem::path(template_path).filename().string();
|
|
|
|
std::vector<std::string> required_files = {
|
|
"example/service.env",
|
|
"example/.template_info.env",
|
|
"_default.env",
|
|
"install.sh",
|
|
"uninstall.sh"
|
|
};
|
|
|
|
for (const auto& file : required_files) {
|
|
if (!required_file(template_path + "/" + file, template_name))
|
|
return false;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// check TEMPLATE= line.
|
|
std::map<std::string, std::string> all_env_vars;
|
|
std::vector<std::string> env_files = {
|
|
"example/service.env",
|
|
"example/.template_info.env"
|
|
};
|
|
for (const auto& file : env_files) {
|
|
{ // load service.env from the service on this machine.
|
|
std::map<std::string, std::string> env_vars;
|
|
envmanager env_manager(template_path + "/" + file);
|
|
env_manager.load();
|
|
env_manager.get_all_variables(env_vars);
|
|
all_env_vars.merge(env_vars);
|
|
}
|
|
|
|
// determine template name.
|
|
auto it = all_env_vars.find("TEMPLATE");
|
|
if (it == all_env_vars.end()) {
|
|
std::cerr << "Error: TEMPLATE variable not found in " << file << std::endl;
|
|
return false;
|
|
}
|
|
|
|
std::string env_template_name = it->second;
|
|
if (env_template_name.empty()) {
|
|
std::cerr << "Error: TEMPLATE variable is empty in " << file << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (env_template_name != template_name) {
|
|
std::cerr << "Error: TEMPLATE variable is wrong in " << file << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace dropshell
|