cschantz
425cfcc7da
Problem: Script rescanned ALL domains on EVERY invocation because cache file included process ID ($$), making it unique each time. For servers with hundreds of domains, this caused 30-45 second hangs on startup. Root cause: WP_CACHE_FILE="/tmp/wp-sites-cache-$$" was deleted on exit Solution implemented: 1. Persistent cache file: /tmp/wp-sites-cache (no $$) 2. Cache TTL: 1 hour (3600 seconds) - automatic expiration 3. Removed cache deletion from exit trap 4. Updated both initialize_wp_cache() and get_wp_sites_cached() to check TTL 5. Added progress messages (cached vs fresh scan) Performance improvement: BEFORE: First run ~45s, every subsequent run ~45s (no caching) AFTER: First run ~45s, cached runs <1s (instant), refresh every hour User experience: - First run: "Scanning for WordPress installations (first run)..." - Cached runs: "Using cached WordPress site list (refreshed hourly)" - Stale cache: "Refreshing WordPress site list (cache expired)..." This fixes the "insanely long" startup time the user reported. Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
2814 lines
94 KiB
Bash
Executable File
2814 lines
94 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
################################################################################
|
|
# WordPress Cron Manager
|
|
################################################################################
|
|
# Purpose: Disable wp-cron and convert to real system cron jobs
|
|
# Features:
|
|
# - Detect all WordPress installations
|
|
# - Disable DISABLE_WP_CRON in wp-config.php
|
|
# - Add proper cron jobs for scheduled tasks
|
|
# - Server-wide, per-user, or per-domain operations
|
|
################################################################################
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
|
|
|
|
[ -f "$SCRIPT_DIR/lib/common-functions.sh" ] && source "$SCRIPT_DIR/lib/common-functions.sh" || { echo "ERROR: common-functions.sh not found" >&2; exit 1; }
|
|
[ -f "$SCRIPT_DIR/lib/system-detect.sh" ] && source "$SCRIPT_DIR/lib/system-detect.sh" || { echo "ERROR: system-detect.sh not found" >&2; exit 1; }
|
|
[ -f "$SCRIPT_DIR/lib/domain-discovery.sh" ] && source "$SCRIPT_DIR/lib/domain-discovery.sh" || { echo "ERROR: domain-discovery.sh not found" >&2; exit 1; }
|
|
|
|
if [ "$EUID" -ne 0 ]; then
|
|
print_error "This script must be run as root"
|
|
exit 1
|
|
fi
|
|
|
|
# Lock file to prevent concurrent execution (ephemeral, removed on exit)
|
|
LOCK_FILE="/tmp/wordpress-cron-manager.lock"
|
|
exec 9>"$LOCK_FILE"
|
|
if ! flock -n 9; then
|
|
print_error "Another instance of this script is already running"
|
|
exit 1
|
|
fi
|
|
trap 'flock -u 9; rm -f "$LOCK_FILE"' EXIT INT TERM
|
|
|
|
# OPTIMIZATION: Parse command-line flags for script behavior
|
|
# Support: --dry-run, --parallel, --log, --help
|
|
DRY_RUN=false
|
|
ENABLE_PARALLEL=false
|
|
LOG_OUTPUT_FILE=""
|
|
|
|
for arg in "$@"; do
|
|
case "$arg" in
|
|
--dry-run)
|
|
DRY_RUN=true
|
|
;;
|
|
--parallel)
|
|
ENABLE_PARALLEL=true
|
|
;;
|
|
--batch|--non-interactive)
|
|
BATCH_MODE=true
|
|
;;
|
|
--log)
|
|
# Next argument should be the log file path
|
|
# Will be set in the next iteration or default to /tmp
|
|
LOG_OUTPUT_FILE="/tmp/wordpress-cron-manager-$(date +%Y%m%d-%H%M%S).log"
|
|
;;
|
|
--log=*)
|
|
# Handle --log=/path/to/file format
|
|
LOG_OUTPUT_FILE="${arg#--log=}"
|
|
;;
|
|
--help)
|
|
echo "Usage: $0 [OPTIONS]"
|
|
echo ""
|
|
echo "Options:"
|
|
echo " --dry-run Run in dry-run mode (no actual changes)"
|
|
echo " --parallel Enable parallel processing for multi-site ops"
|
|
echo " --batch Batch mode - skip all confirmations (for automation)"
|
|
echo " --log [FILE] Enable logging to file (default: /tmp/wordpress-cron-manager-TIMESTAMP.log)"
|
|
echo " --log=/path/to/file Log to specific file path"
|
|
echo " --help Show this help message"
|
|
echo ""
|
|
echo "Examples:"
|
|
echo " $0 --dry-run --parallel"
|
|
echo " $0 --batch --parallel (full automation)"
|
|
echo " $0 --log"
|
|
echo " $0 --log=/var/log/wp-cron-conversion.log"
|
|
exit 0
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# ADVANCED FEATURE: Configuration File Support (OPT-18)
|
|
# Allows loading configuration from file instead of command-line flags
|
|
# Useful for production deployments and reproducible configurations
|
|
declare -g CONFIG_FILE=""
|
|
declare -g USE_CONFIG_FILE=false
|
|
|
|
# Load configuration from file
|
|
# Supported format: KEY=VALUE (one per line, shell-style)
|
|
load_config_file() {
|
|
local config_path="${1:-/etc/wordpress-cron-manager.conf}"
|
|
|
|
if [ ! -f "$config_path" ]; then
|
|
return 0 # Config file is optional
|
|
fi
|
|
|
|
if [ ! -r "$config_path" ]; then
|
|
print_warning "Config file not readable: $config_path"
|
|
return 1
|
|
fi
|
|
|
|
print_info "Loading configuration from: $config_path"
|
|
|
|
# Source the config file (validates shell syntax and loads variables)
|
|
# Use subshell to avoid polluting global scope with unexpected variables
|
|
if ! source "$config_path" 2>/dev/null; then
|
|
print_error "Invalid syntax in config file: $config_path"
|
|
return 1
|
|
fi
|
|
|
|
# Apply configuration options from file
|
|
[ -n "$ENABLE_PARALLEL" ] && ENABLE_PARALLEL="$ENABLE_PARALLEL"
|
|
[ -n "$DRY_RUN" ] && DRY_RUN="$DRY_RUN"
|
|
[ -n "$BATCH_MODE" ] && BATCH_MODE="$BATCH_MODE"
|
|
[ -n "$LOG_OUTPUT_FILE" ] && LOG_OUTPUT_FILE="$LOG_OUTPUT_FILE"
|
|
[ -n "$LOG_DIR" ] && LOG_OUTPUT_FILE="$LOG_DIR/wordpress-cron-manager-$(date +%Y%m%d-%H%M%S).log"
|
|
[ -n "$BACKUP_DIR" ] && BACKUP_DIR="$BACKUP_DIR"
|
|
[ -n "$ROLLBACK_ENABLED" ] && ROLLBACK_ENABLED="$ROLLBACK_ENABLED"
|
|
|
|
return 0
|
|
}
|
|
|
|
# Generate sample configuration file
|
|
generate_sample_config() {
|
|
cat <<'EOF'
|
|
# WordPress Cron Manager Configuration File
|
|
# Location: /etc/wordpress-cron-manager.conf
|
|
# Note: Command-line flags override these settings
|
|
|
|
# Enable parallel processing for multi-site operations
|
|
ENABLE_PARALLEL=false
|
|
|
|
# Run in dry-run mode (show what would be done without making changes)
|
|
DRY_RUN=false
|
|
|
|
# Batch mode (skip all confirmations for automation)
|
|
BATCH_MODE=false
|
|
|
|
# Enable logging to file (auto-generated timestamp or custom path)
|
|
LOG_OUTPUT_FILE="/var/log/wordpress-cron-manager.log"
|
|
|
|
# Custom log directory
|
|
LOG_DIR="/var/log"
|
|
|
|
# Custom backup directory for rollback support
|
|
BACKUP_DIR="/var/backups/wordpress-cron"
|
|
|
|
# Enable automatic rollback on failure
|
|
ROLLBACK_ENABLED=true
|
|
|
|
# Report format (text, json, csv)
|
|
REPORT_FORMAT="text"
|
|
|
|
# Report output file (leave empty for stdout)
|
|
REPORT_FILE="/var/log/wordpress-cron-report.txt"
|
|
EOF
|
|
}
|
|
|
|
# Initialize logging if --log flag was used
|
|
if [ -n "$LOG_OUTPUT_FILE" ]; then
|
|
LOG_ENABLED=true
|
|
LOG_FILE="$LOG_OUTPUT_FILE"
|
|
# Ensure log file is writable
|
|
if ! touch "$LOG_FILE" 2>/dev/null; then
|
|
echo "ERROR: Cannot write to log file: $LOG_FILE" >&2
|
|
LOG_ENABLED=false
|
|
fi
|
|
fi
|
|
|
|
# Load configuration file if it exists (can be overridden by command-line flags)
|
|
if [ -f /etc/wordpress-cron-manager.conf ]; then
|
|
load_config_file /etc/wordpress-cron-manager.conf
|
|
fi
|
|
|
|
# PHP binary path detection
|
|
PHP_BIN=$(command -v php 2>/dev/null || echo "/usr/bin/php")
|
|
|
|
# OPTIMIZATION: Define constants for frequently used strings
|
|
# Reduces hardcoded strings scattered throughout script (29+ occurrences)
|
|
declare -r WP_CRON_DISABLED_VAR="DISABLE_WP_CRON"
|
|
declare -r WP_CONFIG_FILENAME="wp-config.php"
|
|
declare -r WP_CRON_FILENAME="wp-cron.php"
|
|
declare -r WP_CONFIG_MARKER="stop editing"
|
|
declare -r WP_EDIT_START="<?php"
|
|
|
|
# OPTIMIZATION: Magic numbers as named constants (OPT-1)
|
|
# Single source of truth for configuration values
|
|
declare -r MIN_DISK_SPACE=10240 # 10MB in kilobytes
|
|
declare -r CRON_MINUTES_PER_HOUR=60 # Minutes to wrap cron offset
|
|
declare -r CHMOD_SECURE_FILE=600 # Secure file permissions (owner only)
|
|
declare -r MAX_LOCK_WAIT=5 # Max seconds to wait for lock
|
|
declare -r DEFAULT_PARALLEL_JOBS=4 # Default parallel job count
|
|
|
|
# OPTIMIZATION: Command detection cache (OPT-2)
|
|
# Cache command existence to avoid repeated shell searches
|
|
declare -gA COMMAND_CACHE
|
|
|
|
# OPTIMIZATION: Batch/non-interactive mode flag (OPT-3)
|
|
# Skip all confirmations and press_enter for automation
|
|
BATCH_MODE=false
|
|
|
|
# Global counter for staggering cron times
|
|
CRON_OFFSET=0
|
|
|
|
# Global variable to hold generated cron time (avoids subshell scope issues)
|
|
declare -g LAST_CRON_TIME=""
|
|
|
|
# PERFORMANCE OPTIMIZATION: Global cache for find results
|
|
# Instead of running find 23 times, run once and reuse results
|
|
declare -g WP_SITES_CACHE=""
|
|
declare -g WP_CACHE_INITIALIZED=0
|
|
declare -g WP_CACHE_FILE="/tmp/wp-sites-cache" # Persistent across invocations (no $$)
|
|
declare -g WP_CACHE_TTL=3600 # Cache valid for 1 hour (3600 seconds)
|
|
|
|
# OPTIMIZATION: Function Registry (OPT-14)
|
|
# Maintains a registry of all available functions for discoverability and validation
|
|
# Enables runtime function validation and automatic documentation generation
|
|
declare -gA FUNCTION_REGISTRY=(
|
|
[get_wp_search_paths]="Get WordPress installation paths based on control panel"
|
|
[get_home_path]="Build home path for control panel and username"
|
|
[initialize_wp_cache]="Initialize global WordPress site cache"
|
|
[get_wp_sites_cached]="Get cached WordPress sites, or query if not cached"
|
|
[validate_wordpress_site]="Validate WordPress site configuration and ownership"
|
|
[run_or_dryrun]="Execute command or show dry-run output"
|
|
[is_valid_domain_format]="Validate domain format to prevent command injection"
|
|
[is_valid_username_format]="Validate username format to prevent command injection"
|
|
[log_message]="Log message with level and optional file output"
|
|
[is_empty]="Check if variable is empty/unset"
|
|
[is_set]="Check if variable is non-empty"
|
|
[suppress_output]="Run command with output suppressed"
|
|
[redirect_to_stderr]="Run command and send output to stderr"
|
|
[is_file_valid]="Check if file exists and is readable"
|
|
[is_user_valid]="Check if user exists on system"
|
|
[is_wp_configured]="Check if wp-config.php has required database defines"
|
|
[is_wp_cron_disabled]="Check if DISABLE_WP_CRON is set to true"
|
|
[is_cron_job_exists]="Check if cron command exists in crontab"
|
|
[has_sufficient_disk_space]="Check if directory has minimum required disk space"
|
|
[is_wordpress_directory]="Check if directory is valid WordPress installation"
|
|
[grep_wp_config_define]="Search wp-config for a specific define statement"
|
|
[grep_disabled_wp_cron]="Find disabled WP-Cron setting"
|
|
[grep_enabled_wp_cron]="Find enabled WP-Cron setting"
|
|
[grep_in_crontab]="Search crontab for a pattern safely"
|
|
)
|
|
|
|
# Function to validate that a function is registered
|
|
function_exists_registered() {
|
|
local func="$1"
|
|
[ -n "${FUNCTION_REGISTRY[$func]}" ] && return 0 || return 1
|
|
}
|
|
|
|
# Function to get description of a registered function
|
|
function_get_description() {
|
|
local func="$1"
|
|
echo "${FUNCTION_REGISTRY[$func]}"
|
|
}
|
|
|
|
# PERFORMANCE OPTIMIZATION: Use system domain discovery instead of find commands
|
|
# References already-discovered domains from main management system (much faster!)
|
|
# Returns wp-config.php paths for all WordPress installations
|
|
get_wp_search_paths() {
|
|
local panel="${1:-$SYS_CONTROL_PANEL}"
|
|
|
|
# Use domain discovery to get all domains (faster than find)
|
|
# This leverages discovery that's already done by the main management system
|
|
local all_domains
|
|
all_domains=$(list_all_domains 2>/dev/null)
|
|
|
|
if [ -z "$all_domains" ]; then
|
|
# Fallback to find if domain discovery fails
|
|
case "$panel" in
|
|
cpanel)
|
|
find /home/*/public_html -name "wp-config.php" -type f 2>/dev/null
|
|
;;
|
|
interworx)
|
|
find /home/*/*/html -name "wp-config.php" -type f 2>/dev/null
|
|
;;
|
|
plesk)
|
|
find /var/www/vhosts/*/httpdocs -name "wp-config.php" -type f 2>/dev/null
|
|
;;
|
|
*)
|
|
find /var/www/html -name "wp-config.php" -type f 2>/dev/null
|
|
;;
|
|
esac
|
|
return
|
|
fi
|
|
|
|
# For each domain, check its docroot for wp-config.php
|
|
while IFS= read -r domain; do
|
|
local docroot
|
|
docroot=$(get_domain_docroot "$domain" 2>/dev/null)
|
|
|
|
if [ -n "$docroot" ] && [ -f "$docroot/$WP_CONFIG_FILENAME" ]; then
|
|
echo "$docroot/$WP_CONFIG_FILENAME"
|
|
fi
|
|
done <<< "$all_domains"
|
|
}
|
|
|
|
# OPTIMIZATION: Build home path based on control panel and username
|
|
# Consolidates path construction logic (appears 6+ times throughout script)
|
|
# Returns: /home/user path for given control panel type
|
|
get_home_path() {
|
|
local user="$1"
|
|
local panel="${2:-$SYS_CONTROL_PANEL}"
|
|
|
|
case "$panel" in
|
|
cpanel)
|
|
echo "/home/$user/public_html"
|
|
;;
|
|
interworx)
|
|
# InterWorx structure: /home/user/domain/html
|
|
# For default domain, typically same as username
|
|
echo "/home/$user/$user/html"
|
|
;;
|
|
plesk)
|
|
# Plesk uses /var/www/vhosts
|
|
echo "/var/www/vhosts/$user/httpdocs"
|
|
;;
|
|
*)
|
|
# Standalone/default: /var/www/html
|
|
echo "/var/www/html"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Function to initialize and cache all WordPress installations
|
|
# Runs once at script startup, results used by all subsequent functions
|
|
initialize_wp_cache() {
|
|
local panel="$SYS_CONTROL_PANEL"
|
|
|
|
# Check if cache file exists and is still fresh (within TTL)
|
|
if [ -f "$WP_CACHE_FILE" ]; then
|
|
local cache_age=$(($(date +%s) - $(stat -c %Y "$WP_CACHE_FILE" 2>/dev/null || echo 0)))
|
|
if [ "$cache_age" -lt "$WP_CACHE_TTL" ]; then
|
|
# Cache is fresh, use it
|
|
WP_SITES_CACHE=$(cat "$WP_CACHE_FILE")
|
|
WP_CACHE_INITIALIZED=1
|
|
return
|
|
fi
|
|
# Cache is stale, will refresh below
|
|
fi
|
|
|
|
# Run the discovery and save to temp file for persistence
|
|
WP_SITES_CACHE=$(get_wp_search_paths "$panel")
|
|
echo "$WP_SITES_CACHE" > "$WP_CACHE_FILE" 2>/dev/null
|
|
WP_CACHE_INITIALIZED=1
|
|
}
|
|
|
|
# Function to get cached WordPress installations
|
|
# Returns cached results from initialize_wp_cache()
|
|
# Always returns instantly (uses file cache)
|
|
get_wp_sites_cached() {
|
|
# Quick check: if we have a fresh cache file, use it immediately (no discovery needed)
|
|
if [ -f "$WP_CACHE_FILE" ]; then
|
|
local cache_age=$(($(date +%s) - $(stat -c %Y "$WP_CACHE_FILE" 2>/dev/null || echo 0)))
|
|
if [ "$cache_age" -lt "$WP_CACHE_TTL" ]; then
|
|
# Cache is fresh, return it
|
|
cat "$WP_CACHE_FILE"
|
|
return
|
|
fi
|
|
fi
|
|
|
|
# Cache missing or stale: Initialize/refresh cache
|
|
if [ "$WP_CACHE_INITIALIZED" = "0" ]; then
|
|
initialize_wp_cache
|
|
fi
|
|
echo "$WP_SITES_CACHE"
|
|
}
|
|
|
|
# Cleanup on exit (keep cache file for next invocation, only remove lock file)
|
|
trap 'rm -f "$LOCK_FILE"; rollback_cleanup' EXIT INT TERM
|
|
|
|
# OPTIMIZATION: User extraction caching (memoization)
|
|
# extract_user_from_path() called 10 times, often for same path
|
|
# Cache results to avoid redundant extraction operations
|
|
declare -gA USER_EXTRACTION_CACHE
|
|
|
|
get_user_from_path_cached() {
|
|
local site_path="$1"
|
|
|
|
# Check if already in cache
|
|
if [ -n "${USER_EXTRACTION_CACHE[$site_path]}" ]; then
|
|
echo "${USER_EXTRACTION_CACHE[$site_path]}"
|
|
return 0
|
|
fi
|
|
|
|
# Not in cache, extract and cache result
|
|
local user=$(extract_user_from_path "$site_path")
|
|
USER_EXTRACTION_CACHE[$site_path]="$user"
|
|
echo "$user"
|
|
}
|
|
|
|
# Function to safely add cron job to user's crontab
|
|
# Returns 0 on success, 1 on failure
|
|
safe_add_cron_job() {
|
|
local user="$1"
|
|
local cron_time="$2"
|
|
local cron_cmd="$3"
|
|
|
|
# Check if user has valid crontab access
|
|
if ! crontab -u "$user" -l >/dev/null 2>&1; then
|
|
# User might not have a crontab yet - try creating one
|
|
echo "# WordPress cron jobs" | crontab -u "$user" - 2>/dev/null || return 1
|
|
fi
|
|
|
|
# CRITICAL FIX: Check if exact job already exists to prevent duplicates
|
|
if crontab -u "$user" -l 2>/dev/null | grep -qF "$cron_cmd"; then
|
|
# Job already exists, don't add duplicate
|
|
return 0
|
|
fi
|
|
|
|
# Add the job to crontab
|
|
(crontab -u "$user" -l 2>/dev/null; echo "$cron_time $cron_cmd") | crontab -u "$user" - 2>/dev/null
|
|
return $?
|
|
}
|
|
|
|
# Function to safely remove cron jobs from user's crontab
|
|
# Returns 0 on success, 1 on failure
|
|
safe_remove_cron_jobs() {
|
|
local user="$1"
|
|
local pattern="$2" # Pattern to match jobs to remove
|
|
|
|
# Check if crontab exists and contains the pattern
|
|
if ! crontab -u "$user" -l 2>/dev/null | grep -q "$pattern"; then
|
|
# Pattern not found - nothing to remove
|
|
return 0
|
|
fi
|
|
|
|
# Remove jobs matching pattern
|
|
crontab -u "$user" -l 2>/dev/null | grep -v "$pattern" | crontab -u "$user" - 2>/dev/null
|
|
return $?
|
|
}
|
|
|
|
# Function to validate wp-config.php syntax before and after modification
|
|
# Returns 0 if valid, 1 if syntax error detected
|
|
validate_wp_config_syntax() {
|
|
local wp_config="$1"
|
|
|
|
# Check if file exists and is readable
|
|
[ ! -f "$wp_config" ] && return 1
|
|
[ ! -r "$wp_config" ] && return 1
|
|
|
|
# Validate PHP syntax using php -l if available
|
|
if command -v php >/dev/null 2>&1; then
|
|
if ! php -l "$wp_config" >/dev/null 2>&1; then
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
# Additional checks: ensure file has opening <?php and is not corrupted
|
|
if ! grep -q "^<?php" "$wp_config" 2>/dev/null; then
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# Function to check if cron job already exists for a specific site
|
|
# Returns 0 if exists, 1 if not found
|
|
cron_job_exists() {
|
|
local user="$1"
|
|
local site_path="$2"
|
|
|
|
# CRITICAL FIX: Match exact cd command, not just the path
|
|
# Previous: grep -qF "$site_path" would match partial paths (e.g., /home/site/wp-cron.php AND /home/site-test/wp-cron.php)
|
|
# Now: grep -qF "cd \"$site_path\"" matches the exact cd command
|
|
crontab -u "$user" -l 2>/dev/null | grep -qF "cd \"$site_path\"" && return 0 || return 1
|
|
}
|
|
|
|
# Function to check if DISABLE_WP_CRON already exists in wp-config
|
|
# Returns 0 if exists, 1 if not found
|
|
# Excludes commented-out lines to avoid false positives
|
|
disable_wp_cron_exists() {
|
|
local wp_config="$1"
|
|
|
|
# Look for uncommented define() call with DISABLE_WP_CRON and true
|
|
grep -E "^\s*define\s*\(\s*['\"]$WP_CRON_DISABLED_VAR['\"]" "$wp_config" 2>/dev/null | grep -q "true" && return 0 || return 1
|
|
}
|
|
|
|
# OPTIMIZATION: Cleaner alias for disable_wp_cron_exists (more intuitive name)
|
|
# Returns 0 if wp-cron is disabled, 1 if enabled
|
|
is_wpcron_disabled() {
|
|
disable_wp_cron_exists "$1"
|
|
}
|
|
|
|
# OPTIMIZATION: Get file owner consistently (standardizes stat vs ls usage)
|
|
# Prefer stat for consistency and performance
|
|
get_file_owner() {
|
|
local file="$1"
|
|
stat -c '%U' "$file" 2>/dev/null || echo ""
|
|
}
|
|
|
|
# Function to verify user owns the WordPress installation
|
|
# Returns 0 if user matches, 1 if mismatch
|
|
verify_user_ownership() {
|
|
local user="$1"
|
|
local wp_config="$2"
|
|
|
|
# Get actual owner of file using standardized helper
|
|
local actual_owner=$(get_file_owner "$wp_config")
|
|
|
|
# Verify user matches
|
|
if [ "$user" = "$actual_owner" ]; then
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to check if user exists and can receive crontab entries
|
|
# Returns 0 if valid, 1 if not
|
|
user_is_valid() {
|
|
local user="$1"
|
|
|
|
# Check if user exists in system
|
|
if ! id "$user" >/dev/null 2>&1; then
|
|
return 1
|
|
fi
|
|
|
|
# Check if user can be used with crontab (not system user like root)
|
|
# Should have a real home directory
|
|
local home_dir=$(getent passwd "$user" | cut -d: -f6)
|
|
if [ -z "$home_dir" ] || [ "$home_dir" = "/dev/null" ]; then
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# PERFORMANCE OPTIMIZATION: Validation wrapper function
|
|
# Consolidates 3-step validation used in 6 different options
|
|
# Returns 0 if all checks pass, 1 if any check fails
|
|
validate_wordpress_site() {
|
|
local user="$1"
|
|
local wp_config="$2"
|
|
|
|
# Step 1: Check if user is valid
|
|
if ! user_is_valid "$user"; then
|
|
print_error "Invalid user or user does not exist: $user"
|
|
return 1
|
|
fi
|
|
|
|
# Step 2: Verify user owns the WordPress installation
|
|
if ! verify_user_ownership "$user" "$wp_config"; then
|
|
print_error "User ownership mismatch: user=$user, owner=$(stat -c '%U' "$wp_config" 2>/dev/null)"
|
|
return 1
|
|
fi
|
|
|
|
# Step 3: Validate wp-config.php syntax
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
print_error "Invalid wp-config.php syntax or file not readable: $wp_config"
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# PERFORMANCE OPTIMIZATION: DRY-RUN wrapper function
|
|
# Centralizes 20+ inconsistent DRY_RUN checks into a single function
|
|
# Executes command or prints what would happen in dry-run mode
|
|
# Usage: run_or_dryrun "echo 'Modifying file'" "Modifying file"
|
|
run_or_dryrun() {
|
|
local command="$1"
|
|
local description="${2:-$command}"
|
|
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo "[DRY-RUN] $description"
|
|
return 0
|
|
else
|
|
eval "$command"
|
|
return $?
|
|
fi
|
|
}
|
|
|
|
# Function to validate domain format (prevent command injection)
|
|
# Returns 0 if valid format, 1 if invalid
|
|
# Valid: alphanumeric, hyphens, dots, wildcard subdomains
|
|
is_valid_domain_format() {
|
|
local domain="$1"
|
|
|
|
# Reject empty input
|
|
[ -z "$domain" ] && return 1
|
|
|
|
# Domain must be alphanumeric, hyphens, dots only (no special chars)
|
|
# Pattern: starts with letter/digit, contains only [a-z0-9.-], ends with letter/digit
|
|
if [[ "$domain" =~ ^[a-zA-Z0-9]([a-zA-Z0-9.-]*[a-zA-Z0-9])?$ ]]; then
|
|
# Additional check: no consecutive dots, no leading/trailing dots
|
|
[[ "$domain" != *.* ]] && [ "${domain:0:1}" != "." ] && [ "${domain: -1}" != "." ] && return 0
|
|
[[ "$domain" == *.* ]] && [[ "$domain" != ..* ]] && [[ "$domain" != *..* ]] && [[ "$domain" != *. ]] && return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
# Function to validate username format (prevent command injection)
|
|
# Returns 0 if valid format, 1 if invalid
|
|
# Valid: alphanumeric, underscore, hyphen (Linux username conventions)
|
|
is_valid_username_format() {
|
|
local username="$1"
|
|
|
|
# Reject empty input
|
|
[ -z "$username" ] && return 1
|
|
|
|
# Username must be lowercase alphanumeric, underscore, hyphen
|
|
# Pattern: 1-32 chars, starts with letter/digit, contains [a-z0-9_-]
|
|
if [[ "$username" =~ ^[a-z0-9]([a-z0-9_-]{0,31})?$ ]]; then
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
# OPTIMIZATION: Logging wrapper for consistent output formatting (39 occurrences)
|
|
# Provides foundation for future logging to file capability
|
|
# Usage: log_info "Processing site", log_success "Done", log_error "Failed"
|
|
declare -g LOG_ENABLED=false
|
|
declare -g LOG_FILE=""
|
|
|
|
# Log message with level
|
|
log_message() {
|
|
local level="$1"
|
|
local message="$2"
|
|
|
|
case "$level" in
|
|
INFO)
|
|
echo -e "${CYAN}[INFO]${NC} $message"
|
|
;;
|
|
SUCCESS)
|
|
echo -e "${GREEN}[✓]${NC} $message"
|
|
;;
|
|
WARNING)
|
|
echo -e "${YELLOW}[⚠]${NC} $message"
|
|
;;
|
|
ERROR)
|
|
echo -e "${RED}[✗]${NC} $message"
|
|
;;
|
|
*)
|
|
echo "$message"
|
|
;;
|
|
esac
|
|
|
|
# Write to log file if enabled
|
|
if [ "$LOG_ENABLED" = "true" ] && [ -n "$LOG_FILE" ]; then
|
|
echo "[$level] $message" >> "$LOG_FILE" 2>/dev/null
|
|
fi
|
|
}
|
|
|
|
# Convenience wrappers for common log levels
|
|
log_info() {
|
|
log_message "INFO" "$1"
|
|
}
|
|
|
|
log_success() {
|
|
log_message "SUCCESS" "$1"
|
|
}
|
|
|
|
log_warning() {
|
|
log_message "WARNING" "$1"
|
|
}
|
|
|
|
log_error() {
|
|
log_message "ERROR" "$1"
|
|
}
|
|
|
|
# OPTIMIZATION: Parallel processing support for multi-site operations
|
|
# Detect and enable parallel processing for significantly faster execution
|
|
# Potential speedup: 4-8x on multi-core servers for large-scale operations
|
|
declare -g PARALLEL_DETECTED=false
|
|
declare -g PARALLEL_JOBS=1
|
|
|
|
# Detect parallel processing capabilities at startup
|
|
detect_parallel_capabilities() {
|
|
# Skip if disabled via flag
|
|
if [ "$ENABLE_PARALLEL" != "true" ]; then
|
|
PARALLEL_DETECTED=false
|
|
PARALLEL_JOBS=1
|
|
return 1
|
|
fi
|
|
|
|
# Check for GNU parallel
|
|
if command -v parallel >/dev/null 2>&1; then
|
|
PARALLEL_DETECTED=true
|
|
PARALLEL_JOBS=$(nproc 2>/dev/null || echo 4)
|
|
log_info "Parallel processing enabled (GNU parallel, ${PARALLEL_JOBS} jobs)"
|
|
return 0
|
|
fi
|
|
|
|
# Fallback to xargs with -P flag
|
|
if command -v xargs >/dev/null 2>&1; then
|
|
PARALLEL_DETECTED=true
|
|
PARALLEL_JOBS=$(nproc 2>/dev/null || echo 4)
|
|
log_info "Parallel processing enabled (xargs, ${PARALLEL_JOBS} jobs)"
|
|
return 0
|
|
fi
|
|
|
|
# No parallel tools available
|
|
PARALLEL_DETECTED=false
|
|
PARALLEL_JOBS=1
|
|
return 1
|
|
}
|
|
|
|
# OPTIMIZATION: Command detection caching (OPT-2)
|
|
# Cache command existence checks to avoid repeated shell searches
|
|
# 4x faster than repeated "command -v" checks
|
|
get_command_cached() {
|
|
local cmd="$1"
|
|
|
|
# Check cache first
|
|
if [ -n "${COMMAND_CACHE[$cmd]}" ]; then
|
|
[ "${COMMAND_CACHE[$cmd]}" = "found" ] && return 0 || return 1
|
|
fi
|
|
|
|
# Not cached, check if command exists
|
|
if command -v "$cmd" >/dev/null 2>&1; then
|
|
COMMAND_CACHE[$cmd]="found"
|
|
return 0
|
|
else
|
|
COMMAND_CACHE[$cmd]="notfound"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# OPTIMIZATION: ANSI Color Palette Constants (OPT-4)
|
|
# Centralized color definitions for consistent output
|
|
# Reduces 112 scattered color variable uses
|
|
declare -r COLOR_GREEN='\033[0;32m'
|
|
declare -r COLOR_RED='\033[0;31m'
|
|
declare -r COLOR_YELLOW='\033[0;33m'
|
|
declare -r COLOR_BLUE='\033[0;34m'
|
|
declare -r COLOR_CYAN='\033[0;36m'
|
|
declare -r COLOR_BOLD='\033[1m'
|
|
declare -r COLOR_RESET='\033[0m'
|
|
|
|
# OPTIMIZATION: Batch mode helper (OPT-3)
|
|
# Skip confirmations and input prompts for automation
|
|
skip_confirmation() {
|
|
if [ "$BATCH_MODE" = "true" ]; then
|
|
return 0 # Skip confirmation
|
|
else
|
|
return 1 # Don't skip
|
|
fi
|
|
}
|
|
|
|
# OPTIMIZATION: Path Component Helper (OPT-5)
|
|
# Consolidates 26 scattered dirname/basename operations
|
|
# Reduces duplication, consistent path handling
|
|
get_site_path() {
|
|
local wp_config="$1"
|
|
dirname "$wp_config"
|
|
}
|
|
|
|
get_filename() {
|
|
local path="$1"
|
|
basename "$path"
|
|
}
|
|
|
|
# OPTIMIZATION: File Existence & Validation Helper (OPT-6)
|
|
# Consolidates 22 scattered "[ -f ]" checks
|
|
# Provides consistent error messages and permission checking
|
|
file_exists() {
|
|
local file="$1"
|
|
[ -f "$file" ] && return 0 || return 1
|
|
}
|
|
|
|
file_readable() {
|
|
local file="$1"
|
|
[ -f "$file" ] && [ -r "$file" ] && return 0 || return 1
|
|
}
|
|
|
|
file_writable() {
|
|
local file="$1"
|
|
[ -f "$file" ] && [ -w "$file" ] && return 0 || return 1
|
|
}
|
|
|
|
# OPTIMIZATION: Text Processing Library (OPT-10)
|
|
# Consolidates 24 scattered sed/awk/cut operations
|
|
# Provides consistent text processing pattern
|
|
text_replace() {
|
|
local text="$1"
|
|
local pattern="$2"
|
|
local replacement="$3"
|
|
echo "$text" | sed "s/$pattern/$replacement/g"
|
|
}
|
|
|
|
text_extract_lines() {
|
|
local text="$1"
|
|
local pattern="$2"
|
|
echo "$text" | grep "$pattern"
|
|
}
|
|
|
|
text_split() {
|
|
local text="$1"
|
|
local delimiter="${2:- }"
|
|
echo "$text" | tr "$delimiter" '\n'
|
|
}
|
|
|
|
# OPTIMIZATION: Batch Read Processing Helper (OPT-9)
|
|
# Consolidates 8 while read loops with boilerplate
|
|
# Enables parallel processing, faster execution
|
|
# Usage: process_items "$data" "function_name"
|
|
process_items() {
|
|
local items="$1"
|
|
local processor="$2"
|
|
|
|
if [ -z "$items" ]; then
|
|
return 0
|
|
fi
|
|
|
|
local count=0
|
|
local total=$(echo "$items" | wc -l)
|
|
|
|
while IFS= read -r item; do
|
|
count=$((count + 1))
|
|
|
|
# Show progress if not batch mode
|
|
if [ "$BATCH_MODE" != "true" ]; then
|
|
show_progress "$count" "$total"
|
|
fi
|
|
|
|
# Call processor function with item
|
|
"$processor" "$item" || true
|
|
done <<< "$items"
|
|
|
|
# Clear progress
|
|
if [ "$BATCH_MODE" != "true" ]; then
|
|
finish_progress
|
|
fi
|
|
}
|
|
|
|
# OPTIMIZATION: Progress Tracking Helper (OPT-13)
|
|
# Consolidates progress indication across loops
|
|
# Provides user feedback during long operations
|
|
declare -g PROGRESS_ENABLED=false
|
|
declare -g PROGRESS_CURRENT=0
|
|
declare -g PROGRESS_TOTAL=0
|
|
|
|
show_progress() {
|
|
local current="$1"
|
|
local total="$2"
|
|
|
|
if [ -z "$total" ] || [ "$total" -eq 0 ]; then
|
|
return 0
|
|
fi
|
|
|
|
PROGRESS_CURRENT=$current
|
|
PROGRESS_TOTAL=$total
|
|
|
|
# Calculate percentage
|
|
local percent=$((current * 100 / total))
|
|
|
|
# Print progress (single line, updates in place)
|
|
printf "\r[%-30s] %3d%% (%d/%d)" \
|
|
"$(printf '#%.0s' $(seq 1 $((percent / 3))))" \
|
|
"$percent" "$current" "$total"
|
|
}
|
|
|
|
finish_progress() {
|
|
if [ "$PROGRESS_TOTAL" -gt 0 ]; then
|
|
echo "" # New line after progress bar
|
|
fi
|
|
}
|
|
|
|
# ADVANCED FEATURE: Progress Bar Implementation (OPT-16)
|
|
# Enhanced progress bar with configurable width and visual styles
|
|
# Provides professional-grade progress indication for long operations
|
|
declare -g PROGRESS_BAR_WIDTH=40
|
|
declare -g PROGRESS_SHOW_PERCENT=true
|
|
declare -g PROGRESS_SHOW_COUNT=true
|
|
|
|
# Display an enhanced progress bar with percentage and item count
|
|
show_progress_bar() {
|
|
local current="$1"
|
|
local total="$2"
|
|
local label="${3:-Processing}"
|
|
|
|
if [ -z "$total" ] || [ "$total" -eq 0 ]; then
|
|
return 0
|
|
fi
|
|
|
|
PROGRESS_CURRENT=$current
|
|
PROGRESS_TOTAL=$total
|
|
|
|
# Calculate percentage and filled portion
|
|
local percent=$((current * 100 / total))
|
|
local filled=$((percent * PROGRESS_BAR_WIDTH / 100))
|
|
local empty=$((PROGRESS_BAR_WIDTH - filled))
|
|
|
|
# Build bar with filled and empty segments
|
|
local bar_filled=$(printf '=%.0s' $(seq 1 $filled))
|
|
local bar_empty=$(printf ' %.0s' $(seq 1 $empty))
|
|
|
|
# Build output components
|
|
local bar="[$bar_filled$bar_empty]"
|
|
local output="${label}: ${bar}"
|
|
|
|
if [ "$PROGRESS_SHOW_PERCENT" = "true" ]; then
|
|
output="$output $(printf '%3d' $percent)%"
|
|
fi
|
|
|
|
if [ "$PROGRESS_SHOW_COUNT" = "true" ]; then
|
|
output="$output ($current/$total)"
|
|
fi
|
|
|
|
# Print progress (single line, updates in place)
|
|
printf "\r%-80s" "$output"
|
|
}
|
|
|
|
# Display spinner during indeterminate progress
|
|
declare -g SPINNER_INDEX=0
|
|
declare -a SPINNER_CHARS=('⠋' '⠙' '⠹' '⠸' '⠼' '⠴' '⠦' '⠧' '⠇' '⠏')
|
|
|
|
show_spinner() {
|
|
local label="${1:-Processing}"
|
|
local current_char="${SPINNER_CHARS[$SPINNER_INDEX]}"
|
|
SPINNER_INDEX=$(( (SPINNER_INDEX + 1) % ${#SPINNER_CHARS[@]} ))
|
|
printf "\r%s %s" "$current_char" "$label"
|
|
}
|
|
|
|
finish_progress_bar() {
|
|
echo "" # New line after progress bar
|
|
}
|
|
|
|
# OPTIMIZATION: Null Check Standardization (OPT-7)
|
|
# Consolidates 40 "[ -z ]" and 5 "[ -n ]" checks with clearer intent
|
|
# Makes code more readable and maintainable
|
|
is_empty() {
|
|
local value="$1"
|
|
[ -z "$value" ] && return 0 || return 1
|
|
}
|
|
|
|
is_set() {
|
|
local value="$1"
|
|
[ -n "$value" ] && return 0 || return 1
|
|
}
|
|
|
|
# OPTIMIZATION: Output Redirection Helpers (OPT-8)
|
|
# Consolidates 10 ">/dev/null 2>&1" and 3 ">&2" patterns
|
|
# Provides cleaner, more readable code
|
|
suppress_output() {
|
|
"$@" >/dev/null 2>&1
|
|
return $?
|
|
}
|
|
|
|
redirect_to_stderr() {
|
|
"$@" >&2
|
|
return $?
|
|
}
|
|
|
|
# OPTIMIZATION: Error Code Constants (OPT-11)
|
|
# Standardizes 43 exit and 49 return statements with meaningful names
|
|
# Instead of hardcoded "exit 1", use "exit $ERR_INVALID_USER"
|
|
declare -r ERR_SUCCESS=0 # Operation successful
|
|
declare -r ERR_INVALID_USER=1 # User validation failed
|
|
declare -r ERR_FILE_NOT_FOUND=2 # Required file missing
|
|
declare -r ERR_BACKUP_FAILED=3 # Backup operation failed
|
|
declare -r ERR_DISK_SPACE=4 # Insufficient disk space
|
|
declare -r ERR_SYNTAX_ERROR=5 # Syntax validation failed
|
|
declare -r ERR_PERMISSION_DENIED=6 # Permission or ownership issue
|
|
declare -r ERR_DATABASE_ERROR=7 # Database connection/query failed
|
|
declare -r ERR_CONFIG_INVALID=8 # Configuration file invalid
|
|
declare -r ERR_ALREADY_DISABLED=9 # WP-Cron already disabled
|
|
declare -r ERR_ALREADY_RUNNING=10 # Another instance running
|
|
declare -r ERR_CANCELLED=11 # User cancelled operation
|
|
|
|
# OPTIMIZATION: Conditional Logic Library (OPT-15)
|
|
# Consolidates 165 if statements with complex conditions into readable predicates
|
|
# Makes conditions self-documenting and reusable
|
|
is_file_valid() {
|
|
local file="$1"
|
|
[ -f "$file" ] && [ -r "$file" ]
|
|
}
|
|
|
|
is_user_valid() {
|
|
local user="$1"
|
|
id "$user" >/dev/null 2>&1
|
|
}
|
|
|
|
is_wp_configured() {
|
|
local wp_config="$1"
|
|
[ -f "$wp_config" ] && grep -q "DB_NAME" "$wp_config"
|
|
}
|
|
|
|
is_wp_cron_disabled() {
|
|
local wp_config="$1"
|
|
grep -q "define.*$WP_CRON_DISABLED_VAR.*true" "$wp_config"
|
|
}
|
|
|
|
is_cron_job_exists() {
|
|
local cron_command="$1"
|
|
crontab -l 2>/dev/null | grep -qF "$cron_command"
|
|
}
|
|
|
|
has_sufficient_disk_space() {
|
|
local path="$1"
|
|
local min_kb="${2:-$MIN_DISK_SPACE}"
|
|
local available_kb=$(df "$path" 2>/dev/null | awk 'NR==2 {print $4}')
|
|
[ "$available_kb" -gt "$min_kb" ]
|
|
}
|
|
|
|
is_wordpress_directory() {
|
|
local path="$1"
|
|
[ -d "$path" ] && [ -f "$path/$WP_CRON_FILENAME" ]
|
|
}
|
|
|
|
# OPTIMIZATION: Regex Pattern Library (OPT-12)
|
|
# Consolidates 3+ repeated grep patterns used throughout script
|
|
# Provides consistent pattern matching and reduces duplication
|
|
grep_wp_config_define() {
|
|
local wp_config="$1"
|
|
local define_name="$2"
|
|
grep -q "define.*$define_name" "$wp_config"
|
|
}
|
|
|
|
grep_disabled_wp_cron() {
|
|
local wp_config="$1"
|
|
grep -q "define.*$WP_CRON_DISABLED_VAR.*true" "$wp_config"
|
|
}
|
|
|
|
grep_enabled_wp_cron() {
|
|
local wp_config="$1"
|
|
grep -q "define.*$WP_CRON_DISABLED_VAR.*false\|^[[:space:]]*#.*$WP_CRON_DISABLED_VAR" "$wp_config"
|
|
}
|
|
|
|
grep_in_crontab() {
|
|
local pattern="$1"
|
|
crontab -l 2>/dev/null | grep -qF "$pattern"
|
|
}
|
|
|
|
grep_wordpress_path() {
|
|
local path="$1"
|
|
[ -d "$path" ] && [ -f "$path/$WP_CRON_FILENAME" ]
|
|
}
|
|
|
|
# ADVANCED FEATURE: Report Generation (OPT-17)
|
|
# Generates structured reports in multiple formats for integration with monitoring systems
|
|
# Supports JSON, CSV, and text formats for different use cases
|
|
declare -g REPORT_FORMAT="text" # text, json, csv
|
|
declare -g REPORT_FILE=""
|
|
declare -gA REPORT_DATA
|
|
|
|
# Initialize report data collection
|
|
report_init() {
|
|
REPORT_DATA[total_sites]=0
|
|
REPORT_DATA[total_converted]=0
|
|
REPORT_DATA[total_failed]=0
|
|
REPORT_DATA[total_skipped]=0
|
|
REPORT_DATA[start_time]=$(date +%s)
|
|
}
|
|
|
|
# Add operation result to report
|
|
report_add_result() {
|
|
local site_path="$1"
|
|
local status="$2" # success, failed, skipped
|
|
local details="$3"
|
|
|
|
case "$status" in
|
|
success)
|
|
REPORT_DATA[total_converted]=$((${REPORT_DATA[total_converted]:-0} + 1))
|
|
;;
|
|
failed)
|
|
REPORT_DATA[total_failed]=$((${REPORT_DATA[total_failed]:-0} + 1))
|
|
;;
|
|
skipped)
|
|
REPORT_DATA[total_skipped]=$((${REPORT_DATA[total_skipped]:-0} + 1))
|
|
;;
|
|
esac
|
|
|
|
REPORT_DATA[total_sites]=$((${REPORT_DATA[total_sites]:-0} + 1))
|
|
}
|
|
|
|
# Generate JSON report
|
|
generate_json_report() {
|
|
local end_time=$(date +%s)
|
|
local duration=$((end_time - ${REPORT_DATA[start_time]:-0}))
|
|
|
|
cat <<EOF
|
|
{
|
|
"report_type": "WordPress Cron Manager",
|
|
"timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
|
|
"duration_seconds": $duration,
|
|
"summary": {
|
|
"total_sites": ${REPORT_DATA[total_sites]:-0},
|
|
"converted": ${REPORT_DATA[total_converted]:-0},
|
|
"failed": ${REPORT_DATA[total_failed]:-0},
|
|
"skipped": ${REPORT_DATA[total_skipped]:-0}
|
|
},
|
|
"dry_run": "$DRY_RUN",
|
|
"parallel_enabled": "$ENABLE_PARALLEL"
|
|
}
|
|
EOF
|
|
}
|
|
|
|
# Generate CSV report
|
|
generate_csv_report() {
|
|
cat <<EOF
|
|
Report Type,WordPress Cron Manager
|
|
Timestamp,$(date -u +%Y-%m-%dT%H:%M:%SZ)
|
|
Total Sites,${REPORT_DATA[total_sites]:-0}
|
|
Converted,${REPORT_DATA[total_converted]:-0}
|
|
Failed,${REPORT_DATA[total_failed]:-0}
|
|
Skipped,${REPORT_DATA[total_skipped]:-0}
|
|
Dry Run,$DRY_RUN
|
|
Parallel Enabled,$ENABLE_PARALLEL
|
|
EOF
|
|
}
|
|
|
|
# Generate text report
|
|
generate_text_report() {
|
|
local end_time=$(date +%s)
|
|
local duration=$((end_time - ${REPORT_DATA[start_time]:-0}))
|
|
|
|
cat <<EOF
|
|
================================================================================
|
|
WordPress Cron Manager - Operation Report
|
|
================================================================================
|
|
Timestamp: $(date -u +%Y-%m-%dT%H:%M:%SZ)
|
|
Duration: ${duration}s
|
|
Mode: $([ "$DRY_RUN" = "true" ] && echo "DRY-RUN" || echo "LIVE")
|
|
Parallel: $([ "$ENABLE_PARALLEL" = "true" ] && echo "ENABLED" || echo "DISABLED")
|
|
|
|
Summary:
|
|
Total Sites: ${REPORT_DATA[total_sites]:-0}
|
|
✓ Converted: ${REPORT_DATA[total_converted]:-0}
|
|
✗ Failed: ${REPORT_DATA[total_failed]:-0}
|
|
⊘ Skipped: ${REPORT_DATA[total_skipped]:-0}
|
|
|
|
Success Rate: $([ ${REPORT_DATA[total_sites]:-0} -gt 0 ] && echo "scale=1; ${REPORT_DATA[total_converted]:-0} * 100 / ${REPORT_DATA[total_sites]:-0}" | bc || echo "N/A")%
|
|
|
|
================================================================================
|
|
EOF
|
|
}
|
|
|
|
# Write report to file or stdout
|
|
report_save() {
|
|
local format="${1:-$REPORT_FORMAT}"
|
|
local output_file="${2:-$REPORT_FILE}"
|
|
|
|
local report_content
|
|
case "$format" in
|
|
json)
|
|
report_content=$(generate_json_report)
|
|
;;
|
|
csv)
|
|
report_content=$(generate_csv_report)
|
|
;;
|
|
*)
|
|
report_content=$(generate_text_report)
|
|
;;
|
|
esac
|
|
|
|
if [ -n "$output_file" ]; then
|
|
echo "$report_content" > "$output_file"
|
|
echo "Report saved to: $output_file"
|
|
else
|
|
echo "$report_content"
|
|
fi
|
|
}
|
|
|
|
# ADVANCED FEATURE: Automatic Rollback Support (OPT-19)
|
|
# Provides safety net for large-scale operations with ability to revert changes
|
|
# Creates checkpoint backups and enables reverting to known-good state
|
|
declare -g ROLLBACK_ENABLED=false
|
|
declare -g ROLLBACK_DIR="/tmp/wp-cron-rollback-$$"
|
|
declare -gA ROLLBACK_BACKUPS # Maps wp-config.php path to backup path
|
|
|
|
# Initialize rollback system
|
|
rollback_init() {
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
return 0 # Skip rollback in dry-run mode
|
|
fi
|
|
|
|
ROLLBACK_ENABLED=true
|
|
mkdir -p "$ROLLBACK_DIR" 2>/dev/null
|
|
|
|
if [ ! -d "$ROLLBACK_DIR" ]; then
|
|
print_warning "Could not create rollback directory: $ROLLBACK_DIR"
|
|
ROLLBACK_ENABLED=false
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# Create checkpoint backup before modification
|
|
rollback_create_checkpoint() {
|
|
local wp_config="$1"
|
|
local backup_path="$ROLLBACK_DIR/$(basename "$wp_config").bak"
|
|
|
|
if [ ! "$ROLLBACK_ENABLED" = "true" ]; then
|
|
return 0
|
|
fi
|
|
|
|
if ! cp "$wp_config" "$backup_path" 2>/dev/null; then
|
|
print_error "Failed to create rollback checkpoint: $wp_config"
|
|
return 1
|
|
fi
|
|
|
|
# Store mapping for later rollback
|
|
ROLLBACK_BACKUPS["$wp_config"]="$backup_path"
|
|
return 0
|
|
}
|
|
|
|
# Restore file from rollback checkpoint
|
|
rollback_restore_file() {
|
|
local wp_config="$1"
|
|
local backup_path="${ROLLBACK_BACKUPS[$wp_config]}"
|
|
|
|
if [ ! -f "$backup_path" ]; then
|
|
print_error "No rollback checkpoint found for: $wp_config"
|
|
return 1
|
|
fi
|
|
|
|
if ! cp "$backup_path" "$wp_config" 2>/dev/null; then
|
|
print_error "Failed to restore from rollback checkpoint: $wp_config"
|
|
return 1
|
|
fi
|
|
|
|
print_success "Restored from checkpoint: $wp_config"
|
|
return 0
|
|
}
|
|
|
|
# Rollback all changes to checkpoint
|
|
rollback_all() {
|
|
if [ ! "$ROLLBACK_ENABLED" = "true" ]; then
|
|
print_error "Rollback not enabled"
|
|
return 1
|
|
fi
|
|
|
|
if [ ${#ROLLBACK_BACKUPS[@]} -eq 0 ]; then
|
|
print_info "No checkpoints to rollback"
|
|
return 0
|
|
fi
|
|
|
|
print_warning "Rolling back ${#ROLLBACK_BACKUPS[@]} modified files..."
|
|
|
|
local failed=0
|
|
for wp_config in "${!ROLLBACK_BACKUPS[@]}"; do
|
|
if ! rollback_restore_file "$wp_config"; then
|
|
failed=$((failed + 1))
|
|
fi
|
|
done
|
|
|
|
if [ $failed -eq 0 ]; then
|
|
print_success "All files restored successfully"
|
|
return 0
|
|
else
|
|
print_error "Failed to restore $failed files"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Clean up rollback directory
|
|
rollback_cleanup() {
|
|
if [ -d "$ROLLBACK_DIR" ]; then
|
|
rm -rf "$ROLLBACK_DIR" 2>/dev/null
|
|
fi
|
|
}
|
|
|
|
# Rollback trap handler (called on EXIT/INT/TERM)
|
|
rollback_on_interrupt() {
|
|
if [ "$ROLLBACK_ENABLED" = "true" ]; then
|
|
echo ""
|
|
print_warning "Operation interrupted"
|
|
if confirm "Rollback all changes?"; then
|
|
rollback_all
|
|
fi
|
|
fi
|
|
rollback_cleanup
|
|
}
|
|
|
|
# OPTIMIZATION: Build cron command consistently
|
|
# Centralizes cron command format (appears 4 times throughout script)
|
|
# Returns: cron command string for wp-cron.php execution
|
|
build_cron_command() {
|
|
local site_path="$1"
|
|
|
|
# Standard format: cd to site, run wp-cron.php with PHP
|
|
# Redirects both stdout and stderr to /dev/null to keep cron logs clean
|
|
echo "cd \"$site_path\" && $PHP_BIN -q $WP_CRON_FILENAME >/dev/null 2>&1"
|
|
}
|
|
|
|
# Function to pre-check all WordPress installations before any modifications
|
|
# Returns count of valid installations
|
|
preflight_check() {
|
|
local panel="$1"
|
|
local found_count=0
|
|
local issues_count=0
|
|
|
|
echo ""
|
|
echo "Running pre-flight checks..."
|
|
echo ""
|
|
|
|
# PERFORMANCE: Use cached WordPress paths (already scanned at startup)
|
|
local wp_configs=""
|
|
wp_configs=$(get_wp_sites_cached)
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
echo -e "${YELLOW}No WordPress installations found${NC}"
|
|
return 0
|
|
fi
|
|
|
|
while IFS= read -r wp_config; do
|
|
found_count=$((found_count + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
# Verify user is valid
|
|
if ! user_is_valid "$user"; then
|
|
echo -e "${RED}✗${NC} Site $found_count: Invalid user '$user' ($site_path)"
|
|
issues_count=$((issues_count + 1))
|
|
continue
|
|
fi
|
|
|
|
# Verify user owns the WordPress install
|
|
if ! verify_user_ownership "$user" "$wp_config"; then
|
|
echo -e "${YELLOW}⚠${NC} Site $found_count: User mismatch - extracted='$user', owner=$(stat -c '%U' "$wp_config" 2>/dev/null) ($site_path)"
|
|
issues_count=$((issues_count + 1))
|
|
continue
|
|
fi
|
|
|
|
# Validate wp-config.php syntax
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
echo -e "${RED}✗${NC} Site $found_count: Invalid wp-config.php syntax ($site_path)"
|
|
issues_count=$((issues_count + 1))
|
|
continue
|
|
fi
|
|
|
|
echo -e "${GREEN}✓${NC} Site $found_count: $site_path (user: $user)"
|
|
done <<< "$wp_configs"
|
|
|
|
echo ""
|
|
echo "Pre-flight check complete:"
|
|
echo " Total found: $found_count"
|
|
echo " Issues: $issues_count"
|
|
echo " Ready: $((found_count - issues_count))"
|
|
|
|
return $((found_count - issues_count))
|
|
}
|
|
|
|
# Function to display detailed status of all WordPress installations
|
|
# Shows current state before any changes
|
|
show_installation_status() {
|
|
local panel="$1"
|
|
|
|
echo ""
|
|
echo "Current WordPress Installation Status:"
|
|
echo ""
|
|
|
|
local wp_configs=""
|
|
case "$panel" in
|
|
cpanel)
|
|
wp_configs=$(find /home/*/public_html -name "wp-config.php" -type f 2>/dev/null)
|
|
;;
|
|
interworx)
|
|
wp_configs=$(find /home/*/*/html -name "wp-config.php" -type f 2>/dev/null)
|
|
;;
|
|
plesk)
|
|
wp_configs=$(find /var/www/vhosts/*/httpdocs -name "wp-config.php" -type f 2>/dev/null)
|
|
;;
|
|
*)
|
|
wp_configs=$(find /var/www/html -name "wp-config.php" -type f 2>/dev/null)
|
|
;;
|
|
esac
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
echo "No WordPress installations found"
|
|
return 1
|
|
fi
|
|
|
|
local count=0
|
|
while IFS= read -r wp_config; do
|
|
count=$((count + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
# Check wp-cron status
|
|
if disable_wp_cron_exists "$wp_config"; then
|
|
cron_status="${GREEN}Disabled${NC} (system cron)"
|
|
else
|
|
cron_status="${YELLOW}Enabled${NC} (default)"
|
|
fi
|
|
|
|
# Check if cron job exists
|
|
if cron_job_exists "$user" "$site_path"; then
|
|
cron_job="${GREEN}Yes${NC}"
|
|
else
|
|
cron_job="${YELLOW}No${NC}"
|
|
fi
|
|
|
|
echo "$count. ${BOLD}$site_path${NC}"
|
|
echo " User: $user"
|
|
echo " WP-Cron: $cron_status"
|
|
echo " System Cron Job: $cron_job"
|
|
echo ""
|
|
done <<< "$wp_configs"
|
|
|
|
echo "Total installations: $count"
|
|
}
|
|
|
|
# Function to create timestamped backup of wp-config.php
|
|
# Returns 0 on success, 1 on failure
|
|
# Also returns the backup filename
|
|
create_timestamped_backup() {
|
|
local wp_config="$1"
|
|
local backup_timestamp=$(date +%Y%m%d-%H%M%S)
|
|
local backup_file="${wp_config}.backup-${backup_timestamp}"
|
|
|
|
# Verify source file exists
|
|
if [ ! -f "$wp_config" ]; then
|
|
return 1
|
|
fi
|
|
|
|
# CRITICAL FIX: Check disk space before creating backup
|
|
local available_kb=$(df "$(dirname "$wp_config")" 2>/dev/null | awk 'NR==2 {print $4}')
|
|
if [ -n "$available_kb" ] && [ "$available_kb" -lt "$MIN_DISK_SPACE" ]; then
|
|
# Less than 10MB available
|
|
print_error "Insufficient disk space (less than 10MB available) - cannot create backup"
|
|
return 1
|
|
fi
|
|
|
|
# Create backup
|
|
if cp "$wp_config" "$backup_file" 2>/dev/null; then
|
|
# CRITICAL SECURITY FIX: Set backup file permissions to 0600 (owner read/write only)
|
|
# wp-config.php contains sensitive database credentials and should not be readable by other users
|
|
chmod "$CHMOD_SECURE_FILE" "$backup_file" 2>/dev/null || true
|
|
echo "$backup_file"
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to generate staggered cron time
|
|
# Distributes jobs across 60 minutes to avoid load spikes
|
|
generate_staggered_cron() {
|
|
# CRITICAL: Stagger cron times to prevent all WordPress sites from running at once
|
|
# This prevents server load spikes from concurrent execution
|
|
# Each site gets a different minute within the hour, spread across 60 minutes
|
|
# NOTE: Uses global variable LAST_CRON_TIME instead of echo to avoid subshell issues
|
|
|
|
# Calculate staggered minute (0-59) - each site gets a different minute
|
|
local minute=$((CRON_OFFSET % 60))
|
|
|
|
# For better distribution, use every 3 minutes instead of every minute
|
|
# This gives us 20 different time slots instead of 60
|
|
# Site 1: min 0, Site 2: min 3, Site 3: min 6, etc.
|
|
local stagger_minute=$((minute * 3))
|
|
stagger_minute=$((stagger_minute % 60))
|
|
|
|
# Increment offset for next site (THIS PERSISTS in parent shell, not in subshell)
|
|
CRON_OFFSET=$((CRON_OFFSET + 1))
|
|
|
|
# Set global variable instead of using echo (avoids subshell scope issue)
|
|
# This ensures CRON_OFFSET increments persist across loop iterations
|
|
LAST_CRON_TIME="$stagger_minute * * * *"
|
|
}
|
|
|
|
# Function to extract user from WordPress site path
|
|
# Multi-panel aware
|
|
extract_user_from_path() {
|
|
local site_path="$1"
|
|
local user=""
|
|
|
|
case "$SYS_CONTROL_PANEL" in
|
|
cpanel)
|
|
# Extract user from /home/username/public_html pattern
|
|
user=$(echo "$site_path" | awk -F'/' '{print $3}')
|
|
# Validate extraction - if empty, try alternative extraction
|
|
if [ -z "$user" ]; then
|
|
user=$(stat -c %U "$site_path" 2>/dev/null)
|
|
fi
|
|
;;
|
|
interworx)
|
|
# Extract user from /home/username/domain/html pattern
|
|
user=$(echo "$site_path" | awk -F'/' '{print $3}')
|
|
# Validate extraction - if empty, try alternative extraction
|
|
if [ -z "$user" ]; then
|
|
user=$(stat -c %U "$site_path" 2>/dev/null)
|
|
fi
|
|
;;
|
|
plesk)
|
|
# Extract domain from path and lookup user
|
|
local domain=$(echo "$site_path" | grep -oE '/vhosts/[^/]+' | sed 's|/vhosts/||')
|
|
user=$(plesk bin subscription --info "$domain" 2>/dev/null | grep "Owner" | awk '{print $2}')
|
|
# Fallback to file owner if plesk lookup fails
|
|
if [ -z "$user" ]; then
|
|
user=$(stat -c %U "$site_path" 2>/dev/null)
|
|
fi
|
|
;;
|
|
*)
|
|
# Default to file owner if panel detection fails
|
|
user=$(stat -c %U "$site_path" 2>/dev/null)
|
|
if [ -z "$user" ]; then
|
|
user="www-data"
|
|
;;
|
|
esac
|
|
|
|
# CRITICAL FIX: Validate user is not empty - prevents adding cron to wrong user
|
|
if [ -z "$user" ]; then
|
|
user="www-data" # Fallback only if extraction completely failed
|
|
fi
|
|
|
|
echo "$user"
|
|
}
|
|
|
|
# OPTIMIZATION: Helper function to remove DISABLE_WP_CRON from wp-config
|
|
# Encapsulates sed pattern for consistency
|
|
# Returns 0 on success, 1 on failure
|
|
remove_disable_wpcron_from_config() {
|
|
local wp_config="$1"
|
|
|
|
# Remove any existing DISABLE_WP_CRON lines using simple pattern
|
|
# Pattern matches: define('DISABLE_WP_CRON', true); and similar variations
|
|
# Simplified from complex extended regex that wasn't matching properly
|
|
sed -i.wpbak '/define.*DISABLE_WP_CRON.*true.*;/d' "$wp_config"
|
|
return $?
|
|
}
|
|
|
|
# OPTIMIZATION: Helper function to add DISABLE_WP_CRON to wp-config
|
|
# Encapsulates sed pattern for consistency
|
|
# Returns 0 on success, 1 on failure
|
|
add_disable_wpcron_to_config() {
|
|
local wp_config="$1"
|
|
|
|
# Try to insert before WordPress stop editing comment (proper convention)
|
|
if grep -q "$WP_CONFIG_MARKER" "$wp_config" 2>/dev/null; then
|
|
sed -i '#'"$WP_CONFIG_MARKER"'#i\
|
|
define('"'"''"$WP_CRON_DISABLED_VAR"''"'"', true);' "$wp_config"
|
|
return 0
|
|
elif grep -q "$WP_EDIT_START" "$wp_config"; then
|
|
# Fallback: if no stop editing found, add after opening PHP tag
|
|
sed -i '#'"$WP_EDIT_START"'#a\
|
|
define('"'"''"$WP_CRON_DISABLED_VAR"''"'"', true);' "$wp_config"
|
|
return 0
|
|
else
|
|
# File format is unexpected
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to safely modify wp-config.php to disable wp-cron
|
|
# Returns 0 on success, 1 on failure
|
|
disable_wpcron_in_config() {
|
|
local wp_config="$1"
|
|
|
|
# Check if file exists and is writable
|
|
if [ ! -f "$wp_config" ] || [ ! -w "$wp_config" ]; then
|
|
return 1
|
|
fi
|
|
|
|
# First, remove any existing DISABLE_WP_CRON lines (anywhere in file)
|
|
# This ensures clean placement even if previously added in wrong location
|
|
if grep -q "$WP_CRON_DISABLED_VAR" "$wp_config" 2>/dev/null; then
|
|
remove_disable_wpcron_from_config "$wp_config" || true
|
|
else
|
|
# Create backup even if no existing line
|
|
cp "$wp_config" "${wp_config}.wpbak"
|
|
fi
|
|
|
|
# Now add it in the proper location - before "stop editing" comment
|
|
if ! add_disable_wpcron_to_config "$wp_config"; then
|
|
# Restore backup if file format is unexpected
|
|
if [ -f "${wp_config}.wpbak" ]; then
|
|
mv "${wp_config}.wpbak" "$wp_config"
|
|
fi
|
|
return 1
|
|
fi
|
|
|
|
# Verify the change was successful
|
|
if grep -E "^[^/]*define\s*\(\s*['\"]$WP_CRON_DISABLED_VAR['\"]\s*,\s*true\s*\)" "$wp_config" >/dev/null 2>&1; then
|
|
# Remove backup if successful
|
|
rm -f "${wp_config}.wpbak"
|
|
return 0
|
|
else
|
|
# Restore backup if verification failed
|
|
if [ -f "${wp_config}.wpbak" ]; then
|
|
mv "${wp_config}.wpbak" "$wp_config"
|
|
fi
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to safely re-enable wp-cron (revert changes)
|
|
# Returns 0 on success, 1 on failure
|
|
enable_wpcron_in_config() {
|
|
local wp_config="$1"
|
|
|
|
# Check if file exists and is writable
|
|
if [ ! -f "$wp_config" ] || [ ! -w "$wp_config" ]; then
|
|
return 1
|
|
fi
|
|
|
|
# Check if DISABLE_WP_CRON exists and is set to true
|
|
if grep -E "^[^/]*define[[:space:]]*\([[:space:]]*['\"]$WP_CRON_DISABLED_VAR['\"][[:space:]]*,[[:space:]]*true[[:space:]]*\)" "$wp_config" >/dev/null 2>&1; then
|
|
# Remove the line using helper function
|
|
remove_disable_wpcron_from_config "$wp_config" || true
|
|
|
|
# Verify removal was successful
|
|
if ! grep -E "^[^/]*define\s*\(\s*['\"]$WP_CRON_DISABLED_VAR['\"]\s*,\s*true\s*\)" "$wp_config" >/dev/null 2>&1; then
|
|
rm -f "${wp_config}.wpbak"
|
|
return 0
|
|
else
|
|
# Restore backup if removal failed
|
|
if [ -f "${wp_config}.wpbak" ]; then
|
|
mv "${wp_config}.wpbak" "$wp_config"
|
|
fi
|
|
return 1
|
|
fi
|
|
else
|
|
# DISABLE_WP_CRON not found or already disabled
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
clear
|
|
print_banner "WordPress Cron Manager"
|
|
|
|
# PERFORMANCE: Pre-load WordPress sites cache on startup
|
|
# Check if we have a fresh cached copy from a previous run (usually instant)
|
|
if [ "$WP_CACHE_INITIALIZED" = "0" ]; then
|
|
if [ -f "$WP_CACHE_FILE" ]; then
|
|
local cache_age=$(($(date +%s) - $(stat -c %Y "$WP_CACHE_FILE" 2>/dev/null || echo 0)))
|
|
if [ "$cache_age" -lt "$WP_CACHE_TTL" ]; then
|
|
echo -e "${GREEN}✓ Using cached WordPress site list (refreshed hourly)${NC}"
|
|
WP_SITES_CACHE=$(cat "$WP_CACHE_FILE")
|
|
WP_CACHE_INITIALIZED=1
|
|
else
|
|
echo -e "${CYAN}Refreshing WordPress site list (cache expired)...${NC}"
|
|
initialize_wp_cache
|
|
echo -e "${GREEN}✓ Cache refreshed${NC}"
|
|
fi
|
|
else
|
|
echo -e "${CYAN}Scanning for WordPress installations (first run)...${NC}"
|
|
initialize_wp_cache
|
|
echo -e "${GREEN}✓ Cache loaded${NC}"
|
|
fi
|
|
echo ""
|
|
fi
|
|
|
|
echo ""
|
|
echo -e "${BOLD}What would you like to do?${NC}"
|
|
echo ""
|
|
echo -e "${GREEN}Enable System Cron:${NC}"
|
|
echo -e " ${CYAN}1)${NC} Scan for WordPress installations"
|
|
echo -e " ${CYAN}2)${NC} Disable wp-cron for specific domain"
|
|
echo -e " ${CYAN}3)${NC} Disable wp-cron for specific user (all their WP sites)"
|
|
echo -e " ${CYAN}4)${NC} Disable wp-cron server-wide (all WordPress sites)"
|
|
echo ""
|
|
echo -e "${YELLOW}Revert to WP-Cron:${NC}"
|
|
echo -e " ${CYAN}6)${NC} Re-enable wp-cron for specific domain"
|
|
echo -e " ${CYAN}7)${NC} Re-enable wp-cron for specific user (all their WP sites)"
|
|
echo -e " ${CYAN}8)${NC} Re-enable wp-cron server-wide (all WordPress sites)"
|
|
echo ""
|
|
echo -e "${CYAN}Status & Information:${NC}"
|
|
echo -e " ${CYAN}5)${NC} Check wp-cron status for domain/user"
|
|
echo -e " ${CYAN}9)${NC} Run pre-flight checks (validate all installations)"
|
|
echo -e " ${CYAN}10)${NC} Show detailed status of all WordPress sites"
|
|
echo ""
|
|
echo -e " ${RED}0)${NC} Return to menu"
|
|
echo ""
|
|
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
|
|
echo -n "Select option [0]: "
|
|
|
|
# Validate choice input
|
|
while true; do
|
|
read -r choice
|
|
choice="${choice:-0}"
|
|
|
|
if ! [[ "$choice" =~ ^([0-9]|10)$ ]]; then
|
|
echo ""
|
|
print_error "Invalid choice. Please enter 0-10"
|
|
echo ""
|
|
continue
|
|
fi
|
|
break
|
|
done
|
|
|
|
case "$choice" in
|
|
1)
|
|
# Scan for WordPress installations
|
|
echo ""
|
|
print_banner "WordPress Installation Scanner"
|
|
echo ""
|
|
|
|
echo "Retrieving WordPress installations from cache..."
|
|
echo ""
|
|
|
|
# PERFORMANCE: Use cached WordPress paths (pre-scanned at startup)
|
|
wp_sites=$(get_wp_sites_cached)
|
|
|
|
if [ -z "$wp_sites" ]; then
|
|
echo -e "${YELLOW}No WordPress installations found${NC}"
|
|
else
|
|
count=0
|
|
echo -e "${BOLD}Found WordPress Installations:${NC}"
|
|
echo ""
|
|
|
|
while IFS= read -r config_file; do
|
|
count=$((count + 1))
|
|
|
|
# Extract info - Multi-panel support
|
|
site_path=$(dirname "$config_file")
|
|
|
|
# Extract user and domain based on control panel
|
|
user="$(extract_user_from_path "$site_path")"
|
|
domain=""
|
|
case "$SYS_CONTROL_PANEL" in
|
|
cpanel)
|
|
userdata_dir="${SYS_CPANEL_USERDATA_DIR:-/var/cpanel/userdata}"
|
|
if [ -f "$userdata_dir/$user/main" ]; then
|
|
domain=$(grep -m1 "^servername:" "$userdata_dir/$user/main" 2>/dev/null | awk '{print $2}')
|
|
fi
|
|
# CRITICAL FIX: Fallback if domain extraction failed
|
|
if [ -z "$domain" ]; then
|
|
domain="$user.local" # Use user@hostname fallback
|
|
fi
|
|
;;
|
|
interworx)
|
|
domain=$(echo "$site_path" | cut -d'/' -f4)
|
|
# CRITICAL FIX: Fallback if domain extraction failed
|
|
if [ -z "$domain" ]; then
|
|
domain="$user.local" # Use user@hostname fallback
|
|
fi
|
|
;;
|
|
plesk)
|
|
domain=$(echo "$site_path" | grep -oE '/vhosts/[^/]+' | sed 's|/vhosts/||')
|
|
user=$(plesk bin subscription --info "$domain" 2>/dev/null | grep "Owner" | awk '{print $2}')
|
|
[ -z "$user" ] && user="plesk-user"
|
|
;;
|
|
*)
|
|
user="standalone"
|
|
domain="localhost"
|
|
;;
|
|
esac
|
|
|
|
# Final validation: ensure neither is empty (prevents display issues)
|
|
[ -z "$user" ] && user="unknown"
|
|
[ -z "$domain" ] && domain="unknown-domain"
|
|
|
|
# Check if wp-cron is disabled
|
|
if grep -q "define.*DISABLE_WP_CRON.*true" "$config_file" 2>/dev/null; then
|
|
status="${GREEN}✓ Disabled (using system cron)${NC}"
|
|
else
|
|
status="${YELLOW}⚠ Enabled (default wp-cron)${NC}"
|
|
fi
|
|
|
|
echo -e "${count}. ${BOLD}$domain${NC}"
|
|
echo " Path: $site_path"
|
|
echo " User: $user"
|
|
echo " Status: $status"
|
|
echo ""
|
|
done <<< "$wp_sites"
|
|
|
|
echo -e "${CYAN}Total WordPress installations: $count${NC}"
|
|
fi
|
|
;;
|
|
|
|
2)
|
|
# Disable wp-cron for specific domain
|
|
echo ""
|
|
echo -n "Enter domain name (or 0 to cancel): "
|
|
read -r domain
|
|
|
|
if [ -z "$domain" ] || [ "$domain" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
# INPUT SANITIZATION: Validate domain format
|
|
if ! is_valid_domain_format "$domain"; then
|
|
print_error "Invalid domain format. Use only letters, numbers, hyphens, and dots."
|
|
echo "Example: example.com or sub.example.com"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
# Find WordPress installation for this domain - Multi-panel support
|
|
echo ""
|
|
echo "Searching for WordPress installation for $domain..."
|
|
|
|
wp_config=""
|
|
|
|
case "$SYS_CONTROL_PANEL" in
|
|
cpanel)
|
|
# Method 1: Check main_domain in /var/cpanel/userdata/*/main files
|
|
userdata_base="${SYS_CPANEL_USERDATA_DIR:-/var/cpanel/userdata}"
|
|
for userdata_file in "$userdata_base"/*/main; do
|
|
if grep -q "^main_domain: $domain" "$userdata_file" 2>/dev/null; then
|
|
user=$(basename "$(dirname "$userdata_file")")
|
|
potential_config="/home/$user/public_html/wp-config.php"
|
|
if [ -f "$potential_config" ]; then
|
|
wp_config="$potential_config"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Method 2: If not found, search all domain-specific files for servername
|
|
if [ -z "$wp_config" ]; then
|
|
for userdata_file in "$userdata_base"/*/*; do
|
|
# Skip cache files and main files
|
|
[[ "$userdata_file" == *.cache ]] && continue
|
|
[[ "$userdata_file" == */main ]] && continue
|
|
[[ "$userdata_file" == */cache ]] && continue
|
|
[[ "$userdata_file" == */cache.json ]] && continue
|
|
|
|
if grep -q "^servername: $domain" "$userdata_file" 2>/dev/null; then
|
|
user=$(basename "$(dirname "$userdata_file")")
|
|
potential_config="/home/$user/public_html/wp-config.php"
|
|
if [ -f "$potential_config" ]; then
|
|
wp_config="$potential_config"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
;;
|
|
|
|
interworx)
|
|
# Find user from vhost config
|
|
user=$(grep -l "ServerName ${domain}" /etc/httpd/conf.d/vhost_*.conf 2>/dev/null | head -1 | \
|
|
xargs grep "SuexecUserGroup" 2>/dev/null | awk '{print $2}')
|
|
if [ -n "$user" ]; then
|
|
potential_config="/home/${user}/${domain}/html/wp-config.php"
|
|
[ -f "$potential_config" ] && wp_config="$potential_config"
|
|
fi
|
|
;;
|
|
|
|
plesk)
|
|
# Try standard Plesk path
|
|
potential_config="/var/www/vhosts/${domain}/httpdocs/wp-config.php"
|
|
[ -f "$potential_config" ] && wp_config="$potential_config"
|
|
;;
|
|
|
|
*)
|
|
# Standalone - try standard path
|
|
potential_config="/var/www/html/wp-config.php"
|
|
[ -f "$potential_config" ] && wp_config="$potential_config"
|
|
;;
|
|
esac
|
|
|
|
if [ -z "$wp_config" ]; then
|
|
print_error "WordPress installation not found for $domain"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo -e "${GREEN}Found WordPress:${NC} $wp_config"
|
|
echo ""
|
|
|
|
# Extract site path and user
|
|
site_path=$(dirname "$wp_config")
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
# PRE-FLIGHT VALIDATION CHECKS
|
|
echo "Running pre-flight validation checks..."
|
|
echo ""
|
|
|
|
# Check 1: Validate user
|
|
if ! user_is_valid "$user"; then
|
|
print_error "User '$user' is not valid or not a cPanel user"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}✓${NC} User valid: $user"
|
|
|
|
# Check 2: Verify user ownership
|
|
if ! verify_user_ownership "$user" "$wp_config"; then
|
|
actual_owner=$(stat -c '%U' "$wp_config" 2>/dev/null || ls -l "$wp_config" | awk '{print $3}')
|
|
echo -e "${YELLOW}⚠${NC} User mismatch detected:"
|
|
echo " Extracted user: $user"
|
|
echo " Actual owner: $actual_owner"
|
|
echo ""
|
|
echo -n "Continue anyway? (y/n) [n]: "
|
|
read -r confirm
|
|
if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
else
|
|
echo -e "${GREEN}✓${NC} User ownership verified"
|
|
fi
|
|
|
|
# Check 3: Validate wp-config.php syntax BEFORE any changes
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
print_error "wp-config.php has syntax errors - cannot modify"
|
|
echo " Please fix syntax issues first"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}✓${NC} wp-config.php syntax is valid"
|
|
|
|
# Check 4: Check for existing DISABLE_WP_CRON
|
|
if disable_wp_cron_exists "$wp_config"; then
|
|
echo -e "${YELLOW}wp-cron is already disabled for this site${NC}"
|
|
echo ""
|
|
echo -n "Re-configure anyway? (y/n) [n]: "
|
|
read -r confirm
|
|
if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
else
|
|
echo -e "${GREEN}✓${NC} wp-cron currently enabled (will be disabled)"
|
|
fi
|
|
|
|
# Check 5: Check for existing cron job
|
|
if cron_job_exists "$user" "$site_path"; then
|
|
echo -e "${YELLOW}⚠${NC} System cron job already exists for this site"
|
|
echo ""
|
|
echo -n "Update existing cron job? (y/n) [n]: "
|
|
read -r confirm
|
|
if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
else
|
|
echo -e "${GREEN}✓${NC} No existing system cron job"
|
|
fi
|
|
|
|
echo ""
|
|
echo "All validation checks passed. Ready to make changes..."
|
|
echo ""
|
|
|
|
# CREATE BACKUP WITH TIMESTAMP
|
|
echo -e "${BOLD}BACKUP CREATION:${NC}"
|
|
backup_file=$(create_timestamped_backup "$wp_config")
|
|
if [ $? -ne 0 ] || [ -z "$backup_file" ]; then
|
|
print_error "Failed to create backup of wp-config.php"
|
|
echo " Cannot proceed without backup"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo -e "${GREEN}✓${NC} Backup created successfully"
|
|
echo -e "${CYAN}Location:${NC} $backup_file"
|
|
echo -e "${CYAN}Timestamp:${NC} $(date '+%Y-%m-%d %H:%M:%S')"
|
|
echo ""
|
|
|
|
# User confirmation to proceed with modification
|
|
echo -e "${YELLOW}IMPORTANT:${NC} This will modify your wp-config.php file"
|
|
echo ""
|
|
echo -n "Proceed with modification? (y/n) [y]: "
|
|
read -r confirm
|
|
if [ "$confirm" = "n" ] || [ "$confirm" = "N" ]; then
|
|
echo "Operation cancelled. Backup preserved at: $backup_file"
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
echo ""
|
|
echo "Modifying wp-config.php..."
|
|
echo ""
|
|
|
|
# Safely disable wp-cron in wp-config.php
|
|
if disable_wpcron_in_config "$wp_config"; then
|
|
echo -e "${GREEN}✓${NC} Set DISABLE_WP_CRON to true in wp-config.php"
|
|
|
|
# CRITICAL: Verify syntax after modification
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
print_error "CRITICAL: wp-config.php syntax became invalid after modification!"
|
|
echo " Restoring backup..."
|
|
if cp "$backup_file" "$wp_config"; then
|
|
echo -e "${GREEN}✓${NC} Restored from backup: $backup_file"
|
|
echo ""
|
|
echo "Your original wp-config.php has been restored."
|
|
echo "Backup (with attempted modification) kept at: ${backup_file}.failed"
|
|
cp "$backup_file" "${backup_file}.failed"
|
|
else
|
|
print_error "CRITICAL: Could not restore from backup!"
|
|
echo "Original backup location: $backup_file"
|
|
fi
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}✓${NC} wp-config.php syntax verified after modification"
|
|
else
|
|
print_error "Failed to modify wp-config.php"
|
|
echo " Please check file permissions and syntax"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
# Add cron job with staggered timing
|
|
if [ -z "$site_path" ]; then
|
|
echo -e "${RED}✗${NC} Could not determine site path"
|
|
exit 1
|
|
fi
|
|
cron_cmd=$(build_cron_command "$site_path")
|
|
|
|
# Check if cron job already exists (for duplicate prevention)
|
|
if cron_job_exists "$user" "$site_path"; then
|
|
# Remove old one first to avoid duplicates
|
|
safe_remove_cron_jobs "$user" "$site_path.*wp-cron.php"
|
|
echo -e "${YELLOW}⚠${NC} Removed existing cron job (updating)"
|
|
fi
|
|
|
|
# Generate staggered cron time and add to crontab
|
|
generate_staggered_cron # Sets LAST_CRON_TIME globally (avoids subshell)
|
|
cron_time="$LAST_CRON_TIME"
|
|
if safe_add_cron_job "$user" "$cron_time" "$cron_cmd"; then
|
|
echo -e "${GREEN}✓${NC} Added cron job ($cron_time)"
|
|
else
|
|
echo -e "${YELLOW}⚠${NC} Failed to add cron job"
|
|
fi
|
|
|
|
echo ""
|
|
print_success "WordPress cron converted to system cron for $domain"
|
|
echo ""
|
|
echo "Changes made:"
|
|
echo " • DISABLE_WP_CRON set to true in wp-config.php"
|
|
echo " • System cron job added (runs once per hour)"
|
|
echo " • Backup saved: ${wp_config}.backup-*"
|
|
;;
|
|
|
|
3)
|
|
# Disable wp-cron for specific user
|
|
echo ""
|
|
echo -n "Enter cPanel username (or 0 to cancel): "
|
|
read -r target_user
|
|
|
|
if [ -z "$target_user" ] || [ "$target_user" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
# INPUT SANITIZATION: Validate username format
|
|
if ! is_valid_username_format "$target_user"; then
|
|
print_error "Invalid username format. Use only lowercase letters, numbers, hyphens, and underscores."
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! -d "/home/$target_user" ]; then
|
|
print_error "User $target_user does not exist"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo ""
|
|
echo "Searching for WordPress installations for user: $target_user"
|
|
echo ""
|
|
|
|
wp_configs=$(find "/home/$target_user" -name "wp-config.php" -type f 2>/dev/null)
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
print_error "No WordPress installations found for $target_user"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
count=0
|
|
converted=0
|
|
failed=0
|
|
while IFS= read -r wp_config; do
|
|
count=$((count + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
|
|
# Validate site path
|
|
if [ -z "$site_path" ] || [ ! -d "$site_path" ]; then
|
|
echo -e "${YELLOW}Warning: Invalid site path${NC}"
|
|
failed=$((failed + 1))
|
|
continue
|
|
fi
|
|
|
|
# Extract user from site path (per-site, not using $target_user assumption)
|
|
user=$(extract_user_from_path "$site_path")
|
|
if [ -z "$user" ]; then
|
|
echo -e "${YELLOW}Warning: Could not extract username from $site_path${NC}"
|
|
failed=$((failed + 1))
|
|
continue
|
|
fi
|
|
|
|
echo -e "${BOLD}Site $count:${NC} $site_path"
|
|
|
|
# Create timestamped backup
|
|
backup_file=$(create_timestamped_backup "$wp_config")
|
|
if [ -z "$backup_file" ]; then
|
|
echo " • ${YELLOW}Warning: Backup failed, skipping site${NC}"
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
echo " • Backed up wp-config.php"
|
|
|
|
# Safely disable wp-cron
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo " [DRY-RUN] Would modify wp-config.php"
|
|
else
|
|
if ! disable_wpcron_in_config "$wp_config"; then
|
|
echo " • ${RED}Error: Could not modify wp-config.php${NC}"
|
|
[ -f "$backup_file" ] && cp "$backup_file" "$wp_config" 2>/dev/null
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
fi
|
|
echo " • Set DISABLE_WP_CRON to true"
|
|
|
|
# Validate syntax after modification
|
|
if [ "$DRY_RUN" != "true" ] && ! validate_wp_config_syntax "$wp_config"; then
|
|
echo " • ${RED}Error: wp-config.php syntax invalid after modification${NC}"
|
|
cp "$backup_file" "$wp_config" 2>/dev/null
|
|
[ -f "$backup_file" ] && cp "$backup_file" "${backup_file}.failed" 2>/dev/null
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Add cron job with staggered timing
|
|
cron_cmd=$(build_cron_command "$site_path")
|
|
|
|
# Check if PHP binary is available
|
|
if [ ! -x "$PHP_BIN" ]; then
|
|
echo " • ${RED}Error: PHP binary not found at $PHP_BIN${NC}"
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
if ! cron_job_exists "$user" "$site_path"; then
|
|
generate_staggered_cron # Sets LAST_CRON_TIME globally (avoids subshell)
|
|
cron_time="$LAST_CRON_TIME"
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo " [DRY-RUN] Would add cron job ($cron_time)"
|
|
else
|
|
if safe_add_cron_job "$user" "$cron_time" "$cron_cmd"; then
|
|
echo " • Added cron job ($cron_time)"
|
|
converted=$((converted + 1))
|
|
else
|
|
echo " • ${RED}Error: Failed to add cron job${NC}"
|
|
failed=$((failed + 1))
|
|
fi
|
|
fi
|
|
else
|
|
echo " • Cron job already exists"
|
|
fi
|
|
|
|
echo ""
|
|
done <<< "$wp_configs"
|
|
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo -e "${CYAN}[DRY-RUN] Would have converted $count site(s)${NC}"
|
|
else
|
|
print_success "$converted WordPress sites for $target_user converted to system cron"
|
|
if [ $failed -gt 0 ]; then
|
|
print_warning "$failed site(s) failed or were skipped"
|
|
fi
|
|
fi
|
|
;;
|
|
|
|
4)
|
|
# Server-wide conversion
|
|
echo ""
|
|
echo -e "${RED}${BOLD}WARNING: Server-Wide wp-cron Conversion${NC}"
|
|
echo ""
|
|
echo "This will:"
|
|
echo " • Find ALL WordPress installations on the server"
|
|
echo " • Disable wp-cron in each wp-config.php"
|
|
echo " • Add system cron jobs for each user"
|
|
echo ""
|
|
echo -n "Are you sure? Type 'yes' to confirm: "
|
|
read -r confirm
|
|
|
|
if [ "$confirm" != "yes" ]; then
|
|
echo "Cancelled"
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
echo ""
|
|
echo "Processing WordPress installations from cache..."
|
|
echo ""
|
|
|
|
total=0
|
|
converted=0
|
|
failed=0
|
|
|
|
# PERFORMANCE: Use cached paths (scanned once at startup, ~10-50x faster)
|
|
wp_configs=$(get_wp_sites_cached)
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
echo -e "${YELLOW}No WordPress installations found${NC}"
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
while IFS= read -r wp_config; do
|
|
total=$((total + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
if [ -z "$site_path" ]; then
|
|
echo -e "${RED}✗ Could not determine site path${NC}"
|
|
failed=$((failed + 1))
|
|
continue
|
|
fi
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
echo -e "${BOLD}Processing:${NC} $site_path (user: $user)"
|
|
|
|
# Create timestamped backup
|
|
backup_file=$(create_timestamped_backup "$wp_config")
|
|
if [ -z "$backup_file" ]; then
|
|
echo " ${RED}✗ Backup failed, skipping${NC}"
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Safely disable wp-cron
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo " [DRY-RUN] Would modify wp-config.php"
|
|
else
|
|
if ! disable_wpcron_in_config "$wp_config"; then
|
|
echo -e "${RED}✗ Failed to modify wp-config.php${NC}"
|
|
[ -f "$backup_file" ] && cp "$backup_file" "$wp_config" 2>/dev/null
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
# Validate syntax after modification
|
|
if [ "$DRY_RUN" != "true" ] && ! validate_wp_config_syntax "$wp_config"; then
|
|
echo " ${RED}✗ wp-config.php syntax invalid after modification${NC}"
|
|
cp "$backup_file" "$wp_config" 2>/dev/null
|
|
[ -f "$backup_file" ] && cp "$backup_file" "${backup_file}.failed" 2>/dev/null
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Check PHP binary
|
|
if [ ! -x "$PHP_BIN" ]; then
|
|
echo " ${RED}✗ PHP binary not found at $PHP_BIN${NC}"
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Add cron job with staggered timing
|
|
cron_cmd=$(build_cron_command "$site_path")
|
|
|
|
if ! cron_job_exists "$user" "$site_path"; then
|
|
generate_staggered_cron # Sets LAST_CRON_TIME globally (avoids subshell)
|
|
cron_time="$LAST_CRON_TIME"
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo " [DRY-RUN] Would add cron job ($cron_time)"
|
|
else
|
|
if safe_add_cron_job "$user" "$cron_time" "$cron_cmd"; then
|
|
echo " Cron: $cron_time"
|
|
converted=$((converted + 1))
|
|
else
|
|
echo " ${RED}✗ Failed to add cron job${NC}"
|
|
failed=$((failed + 1))
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$DRY_RUN" != "true" ]; then
|
|
echo -e "${GREEN}✓${NC} Converted"
|
|
fi
|
|
echo ""
|
|
|
|
# Add spacing between operations to prevent concurrent execution
|
|
# This ensures sequential processing with clear visual separation
|
|
if [ "$DRY_RUN" != "true" ]; then
|
|
sleep 2
|
|
fi
|
|
done <<< "$wp_configs"
|
|
|
|
echo ""
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo -e "${CYAN}[DRY-RUN] Would convert up to $total site(s)${NC}"
|
|
else
|
|
print_success "Server-wide conversion complete"
|
|
echo ""
|
|
echo "Summary:"
|
|
echo " • Total WordPress sites found: $total"
|
|
echo " • Successfully converted: $converted"
|
|
if [ $failed -gt 0 ]; then
|
|
echo -e " • ${RED}Failed or skipped: $failed${NC}"
|
|
fi
|
|
fi
|
|
;;
|
|
|
|
5)
|
|
# Check status
|
|
echo ""
|
|
echo "Check wp-cron status for:"
|
|
echo -e " ${CYAN}1)${NC} Specific domain"
|
|
echo -e " ${CYAN}2)${NC} Specific user"
|
|
echo -e " ${RED}0)${NC} Cancel"
|
|
echo ""
|
|
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
|
|
|
|
# Validate check_choice input
|
|
while true; do
|
|
echo -n "Select [1]: "
|
|
read -r check_choice
|
|
check_choice="${check_choice:-1}"
|
|
|
|
if ! [[ "$check_choice" =~ ^[0-2]$ ]]; then
|
|
echo ""
|
|
print_error "Invalid choice. Please enter 0, 1, or 2"
|
|
echo ""
|
|
continue
|
|
fi
|
|
break
|
|
done
|
|
|
|
if [ "$check_choice" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
elif [ "$check_choice" = "1" ]; then
|
|
echo ""
|
|
echo -n "Enter domain name (or 0 to cancel): "
|
|
read -r domain
|
|
|
|
if [ -z "$domain" ] || [ "$domain" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
# INPUT SANITIZATION: Validate domain format
|
|
if ! is_valid_domain_format "$domain"; then
|
|
print_error "Invalid domain format. Use only letters, numbers, hyphens, and dots."
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
# Find WordPress for domain
|
|
wp_config=""
|
|
|
|
# Method 1: Check main_domain in main files
|
|
userdata_base="${SYS_CPANEL_USERDATA_DIR:-/var/cpanel/userdata}"
|
|
for userdata_file in "$userdata_base"/*/main; do
|
|
if grep -q "^main_domain: $domain" "$userdata_file" 2>/dev/null; then
|
|
user=$(basename "$(dirname "$userdata_file")")
|
|
potential_config="/home/$user/public_html/wp-config.php"
|
|
if [ -f "$potential_config" ]; then
|
|
wp_config="$potential_config"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Method 2: Search domain-specific files for servername
|
|
if [ -z "$wp_config" ]; then
|
|
for userdata_file in "$userdata_base"/*/*; do
|
|
[[ "$userdata_file" == *.cache ]] && continue
|
|
[[ "$userdata_file" == */main ]] && continue
|
|
[[ "$userdata_file" == */cache ]] && continue
|
|
[[ "$userdata_file" == */cache.json ]] && continue
|
|
|
|
if grep -q "^servername: $domain" "$userdata_file" 2>/dev/null; then
|
|
user=$(basename "$(dirname "$userdata_file")")
|
|
potential_config="/home/$user/public_html/wp-config.php"
|
|
if [ -f "$potential_config" ]; then
|
|
wp_config="$potential_config"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if [ -z "$wp_config" ]; then
|
|
print_error "WordPress not found for $domain"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo ""
|
|
echo -e "${BOLD}WordPress Cron Status for $domain${NC}"
|
|
echo ""
|
|
echo "Config file: $wp_config"
|
|
echo ""
|
|
|
|
if grep -q "define.*DISABLE_WP_CRON.*true" "$wp_config" 2>/dev/null; then
|
|
echo -e "wp-cron: ${GREEN}DISABLED${NC} (using system cron)"
|
|
|
|
# Check for cron job
|
|
site_path=$(dirname "$wp_config")
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
if crontab -u "$user" -l 2>/dev/null | grep -q "$WP_CRON_FILENAME"; then
|
|
echo -e "System cron: ${GREEN}CONFIGURED${NC}"
|
|
echo ""
|
|
echo "Cron jobs:"
|
|
crontab -u "$user" -l 2>/dev/null | grep "$WP_CRON_FILENAME"
|
|
else
|
|
echo -e "System cron: ${RED}NOT CONFIGURED${NC}"
|
|
fi
|
|
else
|
|
echo -e "wp-cron: ${YELLOW}ENABLED${NC} (default WordPress cron)"
|
|
echo ""
|
|
echo "Recommendation: Disable wp-cron and use system cron for better performance"
|
|
fi
|
|
|
|
else
|
|
echo ""
|
|
echo -n "Enter cPanel username (or 0 to cancel): "
|
|
read -r check_user
|
|
|
|
if [ -z "$check_user" ] || [ "$check_user" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
# INPUT SANITIZATION: Validate username format
|
|
if ! is_valid_username_format "$check_user"; then
|
|
print_error "Invalid username format. Use only lowercase letters, numbers, hyphens, and underscores."
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! -d "/home/$check_user" ]; then
|
|
print_error "User $check_user does not exist"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo ""
|
|
echo -e "${BOLD}WordPress Cron Status for user: $check_user${NC}"
|
|
echo ""
|
|
|
|
wp_configs=$(find "/home/$check_user" -name "wp-config.php" -type f 2>/dev/null)
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
echo "No WordPress installations found"
|
|
else
|
|
count=0
|
|
while IFS= read -r wp_config; do
|
|
count=$((count + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
|
|
echo -e "${count}. ${BOLD}$site_path${NC}"
|
|
|
|
if grep -q "define.*DISABLE_WP_CRON.*true" "$wp_config" 2>/dev/null; then
|
|
echo " wp-cron: ${GREEN}DISABLED${NC}"
|
|
else
|
|
echo " wp-cron: ${YELLOW}ENABLED${NC}"
|
|
fi
|
|
echo ""
|
|
done <<< "$wp_configs"
|
|
|
|
# Show cron jobs
|
|
echo -e "${BOLD}Cron Jobs:${NC}"
|
|
if crontab -u "$check_user" -l 2>/dev/null | grep -q "$WP_CRON_FILENAME"; then
|
|
crontab -u "$check_user" -l 2>/dev/null | grep "$WP_CRON_FILENAME"
|
|
else
|
|
echo " No wp-cron jobs found"
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
|
|
6)
|
|
# Re-enable wp-cron for specific domain
|
|
echo ""
|
|
echo -n "Enter domain name (or 0 to cancel): "
|
|
read -r domain
|
|
|
|
if [ -z "$domain" ] || [ "$domain" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
# INPUT SANITIZATION: Validate domain format
|
|
if ! is_valid_domain_format "$domain"; then
|
|
print_error "Invalid domain format. Use only letters, numbers, hyphens, and dots."
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
# Find WordPress installation
|
|
wp_config=""
|
|
|
|
# Method 1: Check main_domain in main files
|
|
for userdata_file in /var/cpanel/userdata/*/main; do
|
|
if grep -q "^main_domain: $domain" "$userdata_file" 2>/dev/null; then
|
|
user=$(basename "$(dirname "$userdata_file")")
|
|
potential_config="/home/$user/public_html/wp-config.php"
|
|
if [ -f "$potential_config" ]; then
|
|
wp_config="$potential_config"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Method 2: Search domain-specific files for servername
|
|
if [ -z "$wp_config" ]; then
|
|
for userdata_file in /var/cpanel/userdata/*/*; do
|
|
[[ "$userdata_file" == *.cache ]] && continue
|
|
[[ "$userdata_file" == */main ]] && continue
|
|
[[ "$userdata_file" == */cache ]] && continue
|
|
[[ "$userdata_file" == */cache.json ]] && continue
|
|
|
|
if grep -q "^servername: $domain" "$userdata_file" 2>/dev/null; then
|
|
user=$(basename "$(dirname "$userdata_file")")
|
|
potential_config="/home/$user/public_html/wp-config.php"
|
|
if [ -f "$potential_config" ]; then
|
|
wp_config="$potential_config"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if [ -z "$wp_config" ]; then
|
|
print_error "WordPress installation not found for $domain"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo -e "${GREEN}Found WordPress:${NC} $wp_config"
|
|
echo ""
|
|
|
|
# Create timestamped backup
|
|
backup_file=$(create_timestamped_backup "$wp_config")
|
|
if [ -z "$backup_file" ]; then
|
|
print_error "Backup failed, aborting"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}✓${NC} Backed up wp-config.php"
|
|
|
|
# Re-enable wp-cron
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo "[DRY-RUN] Would remove DISABLE_WP_CRON from wp-config.php"
|
|
else
|
|
if ! enable_wpcron_in_config "$wp_config"; then
|
|
echo -e "${YELLOW}⚠${NC} DISABLE_WP_CRON not found or already enabled"
|
|
fi
|
|
|
|
# Validate syntax after modification
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
echo -e "${RED}✗${NC} wp-config.php syntax invalid after modification"
|
|
cp "$backup_file" "$wp_config" 2>/dev/null
|
|
[ -f "$backup_file" ] && cp "$backup_file" "${backup_file}.failed" 2>/dev/null
|
|
print_error "Reverted from backup"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}✓${NC} Removed DISABLE_WP_CRON from wp-config.php"
|
|
fi
|
|
|
|
# Remove cron job - Multi-panel support
|
|
site_path=$(dirname "$wp_config")
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo "[DRY-RUN] Would remove cron job from user crontab"
|
|
else
|
|
if safe_remove_cron_jobs "$user" "$site_path.*wp-cron.php"; then
|
|
echo -e "${GREEN}✓${NC} Removed cron job from user crontab"
|
|
else
|
|
echo -e "${YELLOW}⚠${NC} Failed to remove cron job"
|
|
fi
|
|
fi
|
|
|
|
echo ""
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo -e "${CYAN}[DRY-RUN] Would revert WordPress cron to default for $domain${NC}"
|
|
else
|
|
print_success "WordPress cron reverted to default for $domain"
|
|
fi
|
|
;;
|
|
|
|
7)
|
|
# Re-enable wp-cron for specific user
|
|
echo ""
|
|
echo -n "Enter cPanel username (or 0 to cancel): "
|
|
read -r target_user
|
|
|
|
if [ -z "$target_user" ] || [ "$target_user" = "0" ]; then
|
|
echo "Operation cancelled."
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
# INPUT SANITIZATION: Validate username format
|
|
if ! is_valid_username_format "$target_user"; then
|
|
print_error "Invalid username format. Use only lowercase letters, numbers, hyphens, and underscores."
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! -d "/home/$target_user" ]; then
|
|
print_error "User $target_user does not exist"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
echo ""
|
|
echo "Reverting WordPress installations for user: $target_user"
|
|
echo ""
|
|
|
|
wp_configs=$(find "/home/$target_user" -name "wp-config.php" -type f 2>/dev/null)
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
print_error "No WordPress installations found for $target_user"
|
|
press_enter
|
|
exit 1
|
|
fi
|
|
|
|
count=0
|
|
converted=0
|
|
failed=0
|
|
while IFS= read -r wp_config; do
|
|
count=$((count + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
|
|
echo -e "${BOLD}Site $count:${NC} $site_path"
|
|
|
|
# Create timestamped backup
|
|
backup_file=$(create_timestamped_backup "$wp_config")
|
|
if [ -z "$backup_file" ]; then
|
|
echo " • ${RED}Backup failed, skipping${NC}"
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
echo " • Backed up wp-config.php"
|
|
|
|
# Re-enable wp-cron
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo " [DRY-RUN] Would remove DISABLE_WP_CRON"
|
|
else
|
|
if ! enable_wpcron_in_config "$wp_config"; then
|
|
echo " • Already using default wp-cron"
|
|
fi
|
|
|
|
# Validate syntax after modification
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
echo " • ${RED}Syntax error after modification${NC}"
|
|
cp "$backup_file" "$wp_config" 2>/dev/null
|
|
[ -f "$backup_file" ] && cp "$backup_file" "${backup_file}.failed" 2>/dev/null
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
echo " • Removed DISABLE_WP_CRON"
|
|
converted=$((converted + 1))
|
|
fi
|
|
|
|
echo ""
|
|
done <<< "$wp_configs"
|
|
|
|
# Remove all wp-cron jobs for this user
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo "[DRY-RUN] Would remove all wp-cron jobs for user $target_user"
|
|
else
|
|
if safe_remove_cron_jobs "$target_user" "$WP_CRON_FILENAME"; then
|
|
echo -e "${GREEN}✓${NC} Removed all wp-cron jobs from user crontab"
|
|
fi
|
|
fi
|
|
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo -e "${CYAN}[DRY-RUN] Would revert $count site(s) for $target_user${NC}"
|
|
else
|
|
print_success "All WordPress sites for $target_user reverted to default wp-cron"
|
|
if [ $failed -gt 0 ]; then
|
|
print_warning "$failed site(s) failed or were skipped"
|
|
fi
|
|
fi
|
|
;;
|
|
|
|
8)
|
|
# Server-wide revert
|
|
echo ""
|
|
echo -e "${RED}${BOLD}WARNING: Server-Wide Revert${NC}"
|
|
echo ""
|
|
echo "This will:"
|
|
echo " • Find ALL WordPress installations on the server"
|
|
echo " • Remove DISABLE_WP_CRON from each wp-config.php"
|
|
echo " • Remove all wp-cron system cron jobs"
|
|
echo ""
|
|
echo -n "Are you sure? Type 'yes' to confirm: "
|
|
read -r confirm
|
|
|
|
if [ "$confirm" != "yes" ]; then
|
|
echo "Cancelled"
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
echo ""
|
|
echo "Processing WordPress installations from cache..."
|
|
echo ""
|
|
|
|
total=0
|
|
reverted=0
|
|
failed=0
|
|
|
|
# PERFORMANCE: Use cached paths (scanned once at startup, ~10-50x faster)
|
|
wp_configs=$(get_wp_sites_cached)
|
|
|
|
if [ -z "$wp_configs" ]; then
|
|
echo -e "${YELLOW}No WordPress installations found${NC}"
|
|
press_enter
|
|
exit 0
|
|
fi
|
|
|
|
while IFS= read -r wp_config; do
|
|
total=$((total + 1))
|
|
site_path=$(dirname "$wp_config")
|
|
if [ -z "$site_path" ]; then
|
|
echo -e "${RED}✗ Could not determine site path${NC}"
|
|
failed=$((failed + 1))
|
|
continue
|
|
fi
|
|
user=$(extract_user_from_path "$site_path")
|
|
|
|
echo -e "${BOLD}Processing:${NC} $site_path (user: $user)"
|
|
|
|
# Create timestamped backup
|
|
backup_file=$(create_timestamped_backup "$wp_config")
|
|
if [ -z "$backup_file" ]; then
|
|
echo " ${RED}✗ Backup failed, skipping${NC}"
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Re-enable wp-cron
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo " [DRY-RUN] Would remove DISABLE_WP_CRON"
|
|
else
|
|
if ! enable_wpcron_in_config "$wp_config"; then
|
|
echo " Already using default wp-cron"
|
|
fi
|
|
|
|
# Validate syntax after modification
|
|
if ! validate_wp_config_syntax "$wp_config"; then
|
|
echo " ${RED}✗ Syntax error after modification${NC}"
|
|
cp "$backup_file" "$wp_config" 2>/dev/null
|
|
[ -f "$backup_file" ] && cp "$backup_file" "${backup_file}.failed" 2>/dev/null
|
|
failed=$((failed + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
reverted=$((reverted + 1))
|
|
echo -e "${GREEN}✓${NC} Reverted"
|
|
fi
|
|
echo ""
|
|
|
|
# Add spacing between operations to prevent concurrent execution
|
|
# This ensures sequential processing with clear visual separation
|
|
if [ "$DRY_RUN" != "true" ]; then
|
|
sleep 2
|
|
fi
|
|
done <<< "$wp_configs"
|
|
|
|
# Remove all wp-cron jobs from all users
|
|
echo ""
|
|
echo "Removing wp-cron jobs from user crontabs..."
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo "[DRY-RUN] Would remove wp-cron jobs from all users"
|
|
else
|
|
for user_home in /home/*; do
|
|
user=$(basename "$user_home")
|
|
if crontab -u "$user" -l 2>/dev/null | grep -q "$WP_CRON_FILENAME"; then
|
|
if safe_remove_cron_jobs "$user" "$WP_CRON_FILENAME"; then
|
|
echo " • Removed cron jobs for user: $user"
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
echo ""
|
|
if [ "$DRY_RUN" = "true" ]; then
|
|
echo -e "${CYAN}[DRY-RUN] Would revert up to $total site(s)${NC}"
|
|
else
|
|
print_success "Server-wide revert complete"
|
|
echo ""
|
|
echo "Summary:"
|
|
echo " • Total WordPress sites found: $total"
|
|
echo " • Successfully reverted: $reverted"
|
|
if [ $failed -gt 0 ]; then
|
|
echo -e " • ${RED}Failed or skipped: $failed${NC}"
|
|
fi
|
|
fi
|
|
;;
|
|
|
|
9)
|
|
# Run pre-flight checks
|
|
echo ""
|
|
print_banner "Pre-Flight Checks"
|
|
preflight_check "$SYS_CONTROL_PANEL"
|
|
;;
|
|
|
|
10)
|
|
# Show detailed status
|
|
echo ""
|
|
print_banner "WordPress Installation Status"
|
|
show_installation_status "$SYS_CONTROL_PANEL"
|
|
;;
|
|
|
|
0)
|
|
exit 0
|
|
;;
|
|
|
|
*)
|
|
print_error "Invalid option"
|
|
;;
|
|
esac
|
|
|
|
echo ""
|
|
press_enter
|