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

feat: Update 5 and remove 1 files
All checks were successful
Build-Test-Publish / build (linux/amd64) (push) Successful in 53s
Details
Build-Test-Publish / build (linux/arm64) (push) Successful in 2m55s
Details

Browse Source
This commit is contained in:
Your Name
2025-08-29 19:20:52 +12:00
parent 04d240bbd2
commit 6a77e538dd
6 changed files with 89 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
source/agent-remote/_allservicesstatus.sh
View File

@@ -1,170 +0,0 @@
#!/bin/bash
# This script checks ALL services on the server and returns a status for each.
# Return format is simple ENV with the following format:
# SERVICE_NAME_HEALTH=healthy|unhealthy|unknown
# SERVICE_NAME_PORTS=port1,port2,port3
# Get all services on the server
SCRIPT_DIR="$(dirname "$0")"
# export the passed variables from C++, so subshell can use them.
export AGENT_PATH="${AGENT_PATH}"
export HOST_NAME="${HOST_NAME}"
export SERVER="${SERVER}"
# //------------------------------------------------------------------------------------------------
# // remote paths
# // DROPSHELL_DIR
# // |-- backups
# // |-- temp_files
# // |-- agent
# // | |-- bb64
# // | |-- (other agent files, including _allservicesstatus.sh)
# // |-- services
# // |-- service name
# // |-- config
# // |-- service.env (actual service config)
# // |-- .template_info.env
# // |-- template
# // |-- (script files)
# // |-- config
# // |-- service.env (default service config)
# // |-- .template_info.env
# // |-- (other config files for specific server&service)
# Get all services on the server
SERVICES_PATH=$(realpath "${SCRIPT_DIR}/../services/")
CURRENT_OUTPUT=""
CURRENT_EXIT_CODE=0
load_dotenv(){
local file_path=$1
if [ -f "${file_path}" ]; then
# shellcheck source=/dev/null
source "${file_path}"
fi
}
_check_required_env_vars_allservicesstatus() {
local required_vars=("$@")
for var in "${required_vars[@]}"; do
if [ -z "${!var}" ]; then
_die "Required environment variable $var is not set"
fi
done
}
function run_command() {
local service_path=$1
local command=$2
local capture_output=${3:-false} # default to false if not specified
# check if the command is a file
if [ ! -f "${service_path}/template/${command}.sh" ]; then
return;
fi
# run the command in a subshell to prevent environment changes
# This subshell creates a completely isolated environment for each service
CURRENT_OUTPUT=$(
# Start with a clean environment for each service
set -a
# First set the core variables that other env vars might reference
export SERVER="${SERVER}"
export SERVICE_NAME="" # Will be set from .template_info.env
export SERVICE="" # Will be set after loading SERVICE_NAME
export DOCKER_CLI_HINTS=false
export AGENT_PATH="${AGENT_PATH}"
export HOST_NAME="${HOST_NAME}"
# Load the template info first to get SERVICE_NAME and TEMPLATE
load_dotenv "${service_path}/config/.template_info.env"
# Now set SERVICE from SERVICE_NAME (critical for CONTAINER_NAME expansion)
export SERVICE="${SERVICE_NAME}"
# Set CONFIG_PATH before loading service.env as it might be referenced
export CONFIG_PATH="${service_path}/config"
# Now load service.env which can properly expand variables like CONTAINER_NAME=${SERVICE}
load_dotenv "${service_path}/config/service.env"
set +a
_check_required_env_vars_allservicesstatus "CONFIG_PATH" "SERVER" "SERVICE" "AGENT_PATH" "HOST_NAME" "TEMPLATE"
if [ "$capture_output" = "true" ]; then
# Capture and return output
bash "${service_path}/template/${command}.sh" 2>&1
else
# Run silently and return exit code
bash "${service_path}/template/${command}.sh" > /dev/null 2>&1
fi
)
CURRENT_EXIT_CODE=$?
}
function command_exists() {
local service_path=$1
local command=$2
if [ ! -f "${service_path}/template/${command}.sh" ]; then
return 1
fi
return 0
}
if [ ! -d "${SERVICES_PATH}" ]; then
echo "Services path does not exist: ${SERVICES_PATH}"
exit 0
fi
# Get all service names
SERVICE_NAMES=$(ls "${SERVICES_PATH}")
# Iterate over all service names
for SERVICE_NAME in ${SERVICE_NAMES}; do
SERVICE_PATH=$(realpath "${SERVICES_PATH}/${SERVICE_NAME}")
#--------------------------------
# Get the service health
if ! command_exists "${SERVICE_PATH}" "status"; then
SERVICE_HEALTH="unknown"
else
# Debug: capture output to see what's failing
run_command "${SERVICE_PATH}" "status" "true"
ERROR_OUTPUT="${CURRENT_OUTPUT}"
run_command "${SERVICE_PATH}" "status" "false"
if [ "${CURRENT_EXIT_CODE}" -eq 0 ]; then
SERVICE_HEALTH="healthy"
else
SERVICE_HEALTH="unhealthy"
# Debug: show error for simple-object-server services
if [ -f "${SERVICE_PATH}/config/.template_info.env" ]; then
source "${SERVICE_PATH}/config/.template_info.env"
if [ "${TEMPLATE}" = "simple-object-server" ]; then
>&2 echo "DEBUG ${SERVICE_NAME}: ${ERROR_OUTPUT}"
fi
fi
fi
fi
#--------------------------------
# Get the service ports
if ! command_exists "${SERVICE_PATH}" "ports"; then
SERVICE_PORTS=""
else
run_command "${SERVICE_PATH}" "ports" "true"
SERVICE_PORTS="${CURRENT_OUTPUT}"
fi
#--------------------------------
# return the health and ports
echo "${SERVICE_NAME}_HEALTH=${SERVICE_HEALTH}"
echo "${SERVICE_NAME}_PORTS=${SERVICE_PORTS}"
done

1
source/agent-remote/agent-install.sh
View File

@@ -73,7 +73,6 @@ install_bb64
required_files=(
"$AGENT_PATH/bb64"
"$AGENT_PATH/_allservicesstatus.sh"
"$AGENT_PATH/common.sh"
"$AGENT_PATH/datacommands.sh"
)

126
source/src/commands/shared_commands.cpp
View File

@@ -1,11 +1,15 @@
#include "shared_commands.hpp"
#include <libassert/assert.hpp>
#include <algorithm>
#include <sstream>
#include <mutex>
#include "utils/utils.hpp"
#include "servers.hpp"
#include "directories.hpp"
#include "services.hpp"
#include "servers.hpp"
#include "utils/output.hpp"
#include "transwarp.hpp"
namespace dropshell
{
@@ -140,52 +144,43 @@ namespace dropshell
std::map<std::string, ServiceStatus> status;
std::string server_name = server_env.get_server_name();
std::string output;
std::string agentpath = remotepath(server_name,user).agent();
if (!execute_ssh_command(server_env.get_SSH_INFO(user),
sCommand(agentpath, "./_allservicesstatus.sh", {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", agentpath}}),
cMode::Silent,
&output))
return status;
// Get all services for this user on this server
std::vector<LocalServiceInfo> services = get_server_services_info(server_name);
std::stringstream ss(output);
std::string line;
while (std::getline(ss, line))
{
std::string key, value;
std::size_t pos = line.find("=");
if (pos != std::string::npos)
{
key = dequote(trim(line.substr(0, pos)));
value = dequote(trim(line.substr(pos + 1)));
// decode key, it's of format SERVICENAME_[HEALTH|PORTS]
std::string service_name = key.substr(0, key.find_last_of("_"));
std::string status_type = key.substr(key.find_last_of("_") + 1);
if (status_type == "HEALTH")
{ // healthy|unhealthy|unknown
if (value == "healthy")
status[service_name].health = HealthStatus::HEALTHY;
else if (value == "unhealthy")
status[service_name].health = HealthStatus::UNHEALTHY;
else if (value == "unknown")
status[service_name].health = HealthStatus::UNKNOWN;
else
status[service_name].health = HealthStatus::ERROR;
}
else if (status_type == "PORTS")
{ // port1,port2,port3
std::vector<std::string> ports = string2multi(value);
for (const auto &port : ports)
{
if (port != "unknown")
status[service_name].ports.push_back(str2int(port));
}
}
// Filter services for this specific user
std::vector<LocalServiceInfo> user_services;
for (const auto& service : services) {
if (service.user == user) {
user_services.push_back(service);
}
}
// Use parallel execution to check all services simultaneously
// This matches how the list command already works for multiple servers
if (user_services.size() > 0) {
std::mutex status_mutex;
// transwarp requires at least 1 thread
size_t num_threads = std::max(size_t(1), user_services.size());
transwarp::parallel exec{num_threads};
auto task = transwarp::for_each(exec, user_services.begin(), user_services.end(),
[&status, &status_mutex, &server_name](const LocalServiceInfo& service) {
ServiceStatus service_status;
// Get health status using the existing is_healthy function
service_status.health = is_healthy(server_name, service.service_name);
// Get ports using the new get_ports function
service_status.ports = get_ports(server_name, service.service_name);
// Thread-safe update of the status map
std::lock_guard<std::mutex> lock(status_mutex);
status[service.service_name] = service_status;
});
task->wait();
}
return status;
}
@@ -258,6 +253,53 @@ namespace dropshell
return HealthStatus::HEALTHY;
}
// ------------------------------------------------------------------------------------------------
// get_ports : SHARED COMMAND
// ------------------------------------------------------------------------------------------------
std::vector<int> get_ports(const std::string &server, const std::string &service)
{
std::vector<int> ports;
ServerConfig env(server);
if (!env.is_valid())
{
error << "Server service not initialized" << std::endl;
return ports;
}
std::string user = env.get_user_for_service(service);
// Check if ports script exists
std::string script_path = remotepath(server,user).service_template(service) + "/ports.sh";
if (!env.check_remote_file_exists(script_path, user))
{
return ports; // No ports script, return empty
}
// Run ports script and capture output
std::string output;
if (env.run_remote_template_command_and_capture_output(service, "ports", {}, output, true, {}))
{
// Parse the output - expecting comma-separated or newline-separated port numbers
std::stringstream ss(output);
std::string port_str;
while (ss >> port_str)
{
// Remove any commas
port_str.erase(std::remove(port_str.begin(), port_str.end(), ','), port_str.end());
try {
int port = std::stoi(port_str);
if (port > 0 && port <= 65535)
ports.push_back(port);
} catch (...) {
// Ignore non-numeric entries
}
}
}
return ports;
}
// ------------------------------------------------------------------------------------------------
// healthmark : SHARED COMMAND
// ------------------------------------------------------------------------------------------------

1
source/src/commands/shared_commands.hpp
View File

@@ -67,6 +67,7 @@ namespace dropshell
std::string healthtick(const std::string &server, const std::string &service);
std::string HealthStatus2String(HealthStatus status);
HealthStatus is_healthy(const std::string &server, const std::string &service);
std::vector<int> get_ports(const std::string &server, const std::string &service);
std::string healthmark(const std::string &server, const std::string &service);
void std_autocomplete(const CommandContext &ctx);

3
source/src/servers.cpp
View File

@@ -323,7 +323,8 @@ namespace dropshell
for (const auto &[key, value] : extra_env_vars)
scommand->add_env_var(key, value);
return execute_ssh_command(get_SSH_INFO(user), scommand.value(), cMode::Defaults, &output);
// Use Silent mode when capturing output to avoid printing to console
return execute_ssh_command(get_SSH_INFO(user), scommand.value(), cMode::Silent, &output);
}
std::string ServerConfig::get_variable(const std::string &name) const

2
source/src/services.cpp
View File

@@ -140,7 +140,7 @@ namespace dropshell
{ // determine if the service template hash matches the template hash.
auto it = variables.find("TEMPLATE_HASH");
if (it == variables.end())
error << "Variable TEMPLATE_HASH not found in the service " << filenames::template_info_env << std::endl;
error << "Variable TEMPLATE_HASH not found in the service " << filenames::template_info_env << " for "<<server_name << " - "<< service.template_name << std::endl;
else if (tinfo.is_set())
{
uint64_t service_template_hash = std::stoull(it->second);