StakeSquid/ethereum-rpc-docker
1
0
Fork 0
Code Issues 5 Packages Projects Releases Wiki Activity

fixed the ram script

Browse Source
This commit is contained in:
Cursor
2026-02-10 05:37:18 +01:00
parent 641c1d8fa1
commit 63fd119d55
1 changed files with 164 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
show-ram.sh
View File

@@ -5,54 +5,104 @@
# Without argument: shows RAM per node and total server RAM
# With argument: shows containers for specific node
BASEPATH="$(dirname "$0")"
source $BASEPATH/.env
set -euo pipefail
NODE_PATH="$1"
BASEPATH="$(dirname "$0")"
source "$BASEPATH/.env"
NODE_PATH="${1:-}"
# Function to convert memory string to MiB
to_mib() {
local val="$1"
local num=$(echo "$val" | sed 's/[^0-9.]//g')
if [ -z "$num" ] || [ "$num" = "0" ]; then
echo "0"
return
fi
if echo "$val" | grep -qi "GiB"; then
echo "$num * 1024" | bc
echo "$num * 1024" | bc -l | awk '{printf "%.2f", $1}'
elif echo "$val" | grep -qi "MiB"; then
echo "$num"
echo "$num" | awk '{printf "%.2f", $1}'
elif echo "$val" | grep -qi "KiB"; then
echo "$num / 1024" | bc
echo "$num / 1024" | bc -l | awk '{printf "%.2f", $1}'
else
echo "$num"
echo "$num" | awk '{printf "%.2f", $1}'
fi
}
# Function to format MiB to human readable
format_size() {
local mib="$1"
if [ "${mib%.*}" -ge 1024 ] 2>/dev/null; then
echo "scale=2; $mib / 1024" | bc | xargs printf "%.2f GiB"
# Handle empty or zero values
if [ -z "$mib" ] || [ "$mib" = "0" ] || [ "$mib" = "0.00" ]; then
echo "0 MiB"
return
fi
# Compare as float using awk
if awk "BEGIN {exit !($mib >= 1024)}"; then
echo "scale=2; $mib / 1024" | bc -l | xargs printf "%.2f GiB"
else
printf "%.0f MiB" "$mib"
fi
}
# Cache for docker stats (container_id -> mem_usage)
declare -A DOCKER_STATS_CACHE
# Cache for service -> container_id mapping
declare -A SERVICE_TO_CID
# Initialize caches - fetch all container stats once
init_docker_caches() {
# Get all running container IDs with their service labels
while IFS=$'\t' read -r cid service; do
[ -z "$cid" ] && continue
if [ -n "$service" ]; then
SERVICE_TO_CID["$service"]="$cid"
fi
done < <(docker ps --format "{{.ID}}\t{{.Label \"com.docker.compose.service\"}}" 2>/dev/null || true)
# Get stats for all containers at once (much faster than individual calls)
# docker stats can take multiple container IDs, but we'll get all stats in one call
if [ ${#SERVICE_TO_CID[@]} -gt 0 ]; then
local all_cids=($(printf '%s\n' "${SERVICE_TO_CID[@]}" | sort -u))
if [ ${#all_cids[@]} -gt 0 ]; then
# Call docker stats once with all container IDs
while IFS=$'\t' read -r cid mem_usage; do
[ -z "$cid" ] && continue
DOCKER_STATS_CACHE["$cid"]="$mem_usage"
done < <(docker stats --no-stream --format "{{.ID}}\t{{.MemUsage}}" "${all_cids[@]}" 2>/dev/null || true)
fi
fi
}
# Function to get RAM for a compose file by matching service names
get_compose_ram() {
local compose_file="$1"
local total=0
# Get service names defined in this compose file
services=$(cat "$compose_file" | yaml2json - 2>/dev/null | jq -r '.services | keys[]' 2>/dev/null)
local services
services=$(cat "$compose_file" 2>/dev/null | yaml2json - 2>/dev/null | jq -r '.services | keys[]' 2>/dev/null || echo "")
[ -z "$services" ] && echo "0" && return
for service in $services; do
# Find container by service label
cid=$(docker ps -q --filter "label=com.docker.compose.service=$service" 2>/dev/null)
# Use cached container ID
local cid="${SERVICE_TO_CID[$service]:-}"
[ -z "$cid" ] && continue
mem_usage=$(docker stats --no-stream --format "{{.MemUsage}}" "$cid" 2>/dev/null | awk -F'/' '{print $1}')
# Use cached memory usage
local mem_usage="${DOCKER_STATS_CACHE[$cid]:-}"
[ -z "$mem_usage" ] && continue
# Extract just the used memory (before the /)
mem_usage=$(echo "$mem_usage" | awk -F'/' '{print $1}' | xargs)
[ -z "$mem_usage" ] && continue
local mem_mib
mem_mib=$(to_mib "$mem_usage")
total=$(echo "$total + $mem_mib" | bc)
total=$(echo "$total + $mem_mib" | bc -l | awk '{printf "%.2f", $1}')
done
echo "$total"
@@ -76,11 +126,31 @@ if [ -z "$NODE_PATH" ]; then
echo "RAM usage per node:"
echo "========================================"
# Initialize caches once - this batches all docker calls
init_docker_caches
IFS=':' read -ra parts <<< "$COMPOSE_FILE"
declare -A node_ram
total_mib=0
# Export caches to temp files for parallel processing
temp_dir=$(mktemp -d)
trap "rm -rf $temp_dir" EXIT
# Write service->cid mapping to file
for service in "${!SERVICE_TO_CID[@]}"; do
echo "$service|${SERVICE_TO_CID[$service]}" >> "$temp_dir/service_cid.map"
done
# Write cid->mem_usage mapping to file
for cid in "${!DOCKER_STATS_CACHE[@]}"; do
echo "$cid|${DOCKER_STATS_CACHE[$cid]}" >> "$temp_dir/cid_mem.map"
done
# Process nodes in parallel using background jobs
pids=()
for part in "${parts[@]}"; do
# Skip blacklisted files
is_blacklisted "$part" && continue
@@ -91,15 +161,65 @@ if [ -z "$NODE_PATH" ]; then
# Get node path (remove .yml extension)
node_path="${part%.yml}"
# Get RAM usage
ram_mib=$(get_compose_ram "$compose_file")
[ "$ram_mib" = "0" ] && continue
# Process in background for parallel execution
(
# Rebuild caches in this subprocess from temp files
declare -A local_service_cid
declare -A local_cid_mem
node_ram["$node_path"]="$ram_mib"
total_mib=$(echo "$total_mib + $ram_mib" | bc)
while IFS='|' read -r service cid; do
[ -n "$service" ] && [ -n "$cid" ] && local_service_cid["$service"]="$cid"
done < "$temp_dir/service_cid.map" 2>/dev/null || true
while IFS='|' read -r cid mem; do
[ -n "$cid" ] && [ -n "$mem" ] && local_cid_mem["$cid"]="$mem"
done < "$temp_dir/cid_mem.map" 2>/dev/null || true
# Get service names from compose file
services=$(cat "$compose_file" 2>/dev/null | yaml2json - 2>/dev/null | jq -r '.services | keys[]' 2>/dev/null || echo "")
[ -z "$services" ] && exit 0
total=0
for service in $services; do
cid="${local_service_cid[$service]:-}"
[ -z "$cid" ] && continue
mem_usage="${local_cid_mem[$cid]:-}"
[ -z "$mem_usage" ] && continue
mem_usage=$(echo "$mem_usage" | awk -F'/' '{print $1}' | xargs)
[ -z "$mem_usage" ] && continue
mem_mib=$(to_mib "$mem_usage")
total=$(echo "$total + $mem_mib" | bc -l | awk '{printf "%.2f", $1}')
done
if [ "$total" != "0" ]; then
# Sanitize node_path for use as filename (replace / with _)
safe_node_path=$(echo "$node_path" | tr '/' '_')
echo "$total|$node_path" > "$temp_dir/result_$safe_node_path"
fi
) &
pids+=($!)
done
if [ ${#node_ram[@]} -eq 0 ]; then
# Wait for all background jobs to complete
for pid in "${pids[@]}"; do
wait "$pid" 2>/dev/null || true
done
# Collect results
result_count=0
for result_file in "$temp_dir"/result_*; do
[ -f "$result_file" ] || continue
IFS='|' read -r ram_mib node_path < "$result_file"
[ -z "$ram_mib" ] || [ "$ram_mib" = "0" ] && continue
node_ram["$node_path"]="$ram_mib"
total_mib=$(echo "$total_mib + $ram_mib" | bc -l | awk '{printf "%.2f", $1}')
result_count=$((result_count + 1))
done
if [ "$result_count" -eq 0 ]; then
echo "No running nodes found"
exit 0
fi
@@ -107,7 +227,7 @@ if [ -z "$NODE_PATH" ]; then
# Sort by RAM usage and display
for node_path in "${!node_ram[@]}"; do
echo "${node_ram[$node_path]} $node_path"
done | sort -rn | while read mib name; do
done | sort -rn | while IFS=' ' read -r mib name; do
printf "%-55s %s\n" "$name" "$(format_size $mib)"
done
@@ -127,8 +247,11 @@ else
exit 1
fi
# Initialize caches once
init_docker_caches
# Get service names from compose file
services=$(cat "$COMPOSE_FILE_PATH" | yaml2json - 2>/dev/null | jq -r '.services | keys[]' 2>/dev/null)
services=$(cat "$COMPOSE_FILE_PATH" 2>/dev/null | yaml2json - 2>/dev/null | jq -r '.services | keys[]' 2>/dev/null || echo "")
if [ -z "$services" ]; then
echo "No services found in $NODE_PATH"
@@ -140,17 +263,30 @@ else
total_mib=0
for service in $services; do
cid=$(docker ps -q --filter "label=com.docker.compose.service=$service" 2>/dev/null)
# Use cached container ID
cid="${SERVICE_TO_CID[$service]:-}"
[ -z "$cid" ] && continue
mem_info=$(docker stats --no-stream --format "{{.MemUsage}}\t{{.MemPerc}}" "$cid" 2>/dev/null)
mem_usage=$(echo "$mem_info" | awk -F'\t' '{print $1}' | awk -F'/' '{print $1}')
mem_perc=$(echo "$mem_info" | awk -F'\t' '{print $2}')
# Use cached memory usage
mem_info="${DOCKER_STATS_CACHE[$cid]:-}"
if [ -z "$mem_info" ]; then
# Fallback: get stats for this specific container if not in cache
mem_info=$(docker stats --no-stream --format "{{.MemUsage}}\t{{.MemPerc}}" "$cid" 2>/dev/null || echo "")
[ -z "$mem_info" ] && continue
fi
mem_usage=$(echo "$mem_info" | awk -F'\t' '{print $1}' | awk -F'/' '{print $1}' | xargs)
mem_perc=$(echo "$mem_info" | awk -F'\t' '{print $2}' | xargs)
# If we don't have percentage, try to get it separately
if [ -z "$mem_perc" ]; then
mem_perc=$(docker stats --no-stream --format "{{.MemPerc}}" "$cid" 2>/dev/null || echo "")
fi
printf "%-40s %s\t%s\n" "$service" "$mem_usage" "$mem_perc"
mem_mib=$(to_mib "$mem_usage")
total_mib=$(echo "$total_mib + $mem_mib" | bc)
total_mib=$(echo "$total_mib + $mem_mib" | bc -l | awk '{printf "%.2f", $1}')
done
echo "----------------------------------------"