Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Developer
|
ce65004c79 | ||
|
Developer
|
37de22241c |
@@ -284,6 +284,153 @@ detect_mysql_memory_usage() {
|
||||
fi
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# NEW: CALCULATE SERVER TOTAL CAPACITY
|
||||
# ============================================================================
|
||||
# Calculate the total max_children the entire server can support
|
||||
# Usage: calculate_server_capacity <total_ram_mb>
|
||||
# Returns: total_capacity|available_memory|memory_per_process|reason
|
||||
calculate_server_capacity() {
|
||||
local total_ram_mb="$1"
|
||||
|
||||
if [ -z "$total_ram_mb" ] || [ "$total_ram_mb" -lt 512 ]; then
|
||||
echo "0|0|20|Insufficient RAM for calculation"
|
||||
return
|
||||
fi
|
||||
|
||||
# Calculate system reserve (dynamic percentage-based)
|
||||
local reserve_result
|
||||
reserve_result=$(calculate_system_reserve "$total_ram_mb")
|
||||
local reserved_mb
|
||||
reserved_mb=$(get_field "$reserve_result" 1)
|
||||
|
||||
# Account for MySQL memory (critical on shared hosting!)
|
||||
local mysql_memory_mb=0
|
||||
local mysql_info
|
||||
mysql_info=$(detect_mysql_memory_usage 2>/dev/null)
|
||||
if [ $? -eq 0 ]; then
|
||||
mysql_memory_mb=$(echo "$mysql_info" | cut -d'|' -f3)
|
||||
fi
|
||||
|
||||
# Available memory for PHP-FPM (after system + MySQL reserves)
|
||||
local available_mb=$((total_ram_mb - reserved_mb - mysql_memory_mb))
|
||||
|
||||
# Safety check: never allow PHP-FPM to use more than 60% of RAM
|
||||
local max_php_fpm=$((total_ram_mb * 60 / 100))
|
||||
if [ "$available_mb" -gt "$max_php_fpm" ]; then
|
||||
available_mb=$max_php_fpm
|
||||
fi
|
||||
|
||||
# Conservative memory per process for safety (20MB)
|
||||
local memory_per_process=20
|
||||
|
||||
# Total capacity = available memory / memory per process
|
||||
local total_capacity=$((available_mb / memory_per_process))
|
||||
|
||||
# Sanity checks
|
||||
[ "$total_capacity" -lt 5 ] && total_capacity=5
|
||||
[ "$total_capacity" -gt 500 ] && total_capacity=500
|
||||
|
||||
echo "$total_capacity|$available_mb|$memory_per_process|Server can support $total_capacity total max_children"
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# NEW: GET DOMAIN TRAFFIC PERCENTAGE
|
||||
# ============================================================================
|
||||
# Calculate what percentage of total server traffic this domain handles
|
||||
# Usage: get_domain_traffic_percentage <username> <domain> <all_domains_list>
|
||||
# Returns: percentage|request_count|reason
|
||||
get_domain_traffic_percentage() {
|
||||
local username="$1"
|
||||
local domain="$2"
|
||||
local all_domains="$3"
|
||||
|
||||
if [ -z "$domain" ] || [ -z "$all_domains" ]; then
|
||||
echo "50|0|Insufficient data"
|
||||
return
|
||||
fi
|
||||
|
||||
# Find access logs for this domain
|
||||
local access_log
|
||||
access_log=$(find /home/"$username"/*/logs -name "*access*log*" 2>/dev/null | grep "$domain" | head -1)
|
||||
|
||||
if [ -z "$access_log" ] || [ ! -f "$access_log" ]; then
|
||||
# No specific log found, assume equal distribution
|
||||
local domain_count
|
||||
domain_count=$(echo "$all_domains" | wc -l)
|
||||
local percentage=$((100 / domain_count))
|
||||
echo "$percentage|0|No logs found, assuming equal distribution"
|
||||
return
|
||||
fi
|
||||
|
||||
# Count requests for this domain from last 7 days
|
||||
local domain_requests
|
||||
domain_requests=$(find "$access_log" -mtime -7 -exec wc -l {} \; 2>/dev/null | awk '{print $1}')
|
||||
[ -z "$domain_requests" ] && domain_requests=0
|
||||
|
||||
if [ "$domain_requests" -eq 0 ]; then
|
||||
# No recent traffic, use equal distribution
|
||||
local domain_count
|
||||
domain_count=$(echo "$all_domains" | wc -l)
|
||||
local percentage=$((100 / domain_count))
|
||||
echo "$percentage|0|No recent traffic"
|
||||
return
|
||||
fi
|
||||
|
||||
# Count total requests across all domains
|
||||
local total_requests=0
|
||||
while IFS= read -r d; do
|
||||
[ -z "$d" ] && continue
|
||||
local d_log
|
||||
d_log=$(find /home/"$username"/*/logs -name "*access*log*" 2>/dev/null | head -1)
|
||||
if [ -f "$d_log" ]; then
|
||||
local d_count
|
||||
d_count=$(find "$d_log" -mtime -7 -exec wc -l {} \; 2>/dev/null | awk '{print $1}')
|
||||
total_requests=$((total_requests + d_count))
|
||||
fi
|
||||
done <<< "$all_domains"
|
||||
|
||||
if [ "$total_requests" -eq 0 ]; then
|
||||
echo "50|$domain_requests|Insufficient total traffic"
|
||||
return
|
||||
fi
|
||||
|
||||
# Calculate percentage
|
||||
local percentage=$((domain_requests * 100 / total_requests))
|
||||
[ "$percentage" -lt 1 ] && percentage=1
|
||||
[ "$percentage" -gt 99 ] && percentage=99
|
||||
|
||||
echo "$percentage|$domain_requests|Based on $total_requests total requests"
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# NEW: CALCULATE FAIR SHARE BASED ON TRAFFIC
|
||||
# ============================================================================
|
||||
# Calculate this domain's fair share of server capacity based on traffic percentage
|
||||
# Usage: calculate_max_children_fair_share <total_capacity> <traffic_percentage>
|
||||
# Returns: fair_share_max|reason
|
||||
calculate_max_children_fair_share() {
|
||||
local total_capacity="$1"
|
||||
local traffic_percentage="$2"
|
||||
|
||||
if [ -z "$total_capacity" ] || [ -z "$traffic_percentage" ]; then
|
||||
echo "20|Invalid parameters"
|
||||
return
|
||||
fi
|
||||
|
||||
# Calculate fair share: total capacity × traffic percentage
|
||||
local fair_share=$((total_capacity * traffic_percentage / 100))
|
||||
|
||||
# Apply hard limits
|
||||
if [ "$fair_share" -lt 5 ]; then
|
||||
echo "5|Fair share is very small (minimum enforced)"
|
||||
elif [ "$fair_share" -gt 150 ]; then
|
||||
echo "150|Fair share exceeds shared hosting limit (capped at 150)"
|
||||
else
|
||||
echo "$fair_share|Fair share: $traffic_percentage% of $total_capacity total"
|
||||
fi
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# NEW: RECOMMEND PM MODE (static/dynamic/ondemand)
|
||||
# ============================================================================
|
||||
@@ -406,6 +553,92 @@ calculate_optimal_php_settings() {
|
||||
echo "$final_max_children|$pm_mode|$min_spare|$max_spare|$reason_prefix: $pm_reason"
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# NEW: THREE-CONSTRAINT INTELLIGENT OPTIMIZATION
|
||||
# ============================================================================
|
||||
# Calculate optimal settings using three constraints for maximum intelligence:
|
||||
# 1. Memory constraint - what available RAM allows
|
||||
# 2. Traffic constraint - what actual usage suggests
|
||||
# 3. Fair share constraint - proportional allocation based on traffic
|
||||
# Uses the MINIMUM of all three for maximum safety and fairness
|
||||
# Usage: calculate_optimal_php_settings_intelligent <username> <total_ram_mb> <total_server_capacity> <traffic_percentage>
|
||||
# Returns: max_children|pm_mode|min_spare|max_spare|limiting_factor|reason
|
||||
calculate_optimal_php_settings_intelligent() {
|
||||
local username="$1"
|
||||
local total_ram_mb="$2"
|
||||
local total_server_capacity="$3"
|
||||
local traffic_percentage="$4"
|
||||
|
||||
if [ -z "$username" ] || [ -z "$total_ram_mb" ] || [ -z "$total_server_capacity" ]; then
|
||||
echo "0|dynamic|1|5|ERROR|Invalid parameters"
|
||||
return
|
||||
fi
|
||||
|
||||
# Default traffic percentage if not provided (equal distribution)
|
||||
[ -z "$traffic_percentage" ] && traffic_percentage=50
|
||||
|
||||
# CONSTRAINT 1: Memory-based max (what RAM allows)
|
||||
local memory_result
|
||||
memory_result=$(calculate_max_children_memory_based "$username" "$total_ram_mb")
|
||||
local memory_based_max
|
||||
memory_based_max=$(get_field "$memory_result" 1)
|
||||
|
||||
# CONSTRAINT 2: Traffic-based max (what traffic patterns suggest)
|
||||
local traffic_result
|
||||
traffic_result=$(calculate_peak_concurrent_requests_improved "$username" 7)
|
||||
local peak_concurrent stability_factor
|
||||
peak_concurrent=$(get_field "$traffic_result" 1)
|
||||
stability_factor=$(get_field "$traffic_result" 2)
|
||||
|
||||
local traffic_based_max=0
|
||||
if [ "$peak_concurrent" -gt 0 ]; then
|
||||
local traffic_calc
|
||||
traffic_calc=$(calculate_max_children_traffic_based "$peak_concurrent" "$stability_factor")
|
||||
traffic_based_max=$(get_field "$traffic_calc" 1)
|
||||
else
|
||||
traffic_based_max=$memory_based_max # No traffic data, use memory as basis
|
||||
fi
|
||||
|
||||
# CONSTRAINT 3: Fair share (proportional allocation based on traffic %)
|
||||
local fair_share_result
|
||||
fair_share_result=$(calculate_max_children_fair_share "$total_server_capacity" "$traffic_percentage")
|
||||
local fair_share_max
|
||||
fair_share_max=$(get_field "$fair_share_result" 1)
|
||||
|
||||
# USE THE MINIMUM OF ALL THREE CONSTRAINTS
|
||||
local final_max_children="$memory_based_max"
|
||||
local limiting_factor="Memory (${memory_based_max}MB available)"
|
||||
|
||||
if [ "$traffic_based_max" -lt "$final_max_children" ]; then
|
||||
final_max_children="$traffic_based_max"
|
||||
limiting_factor="Traffic (peak ${peak_concurrent} concurrent)"
|
||||
fi
|
||||
|
||||
if [ "$fair_share_max" -lt "$final_max_children" ]; then
|
||||
final_max_children="$fair_share_max"
|
||||
limiting_factor="Fair share (${traffic_percentage}% of server capacity)"
|
||||
fi
|
||||
|
||||
# CRITICAL: Ensure we never recommend 0 or invalid values
|
||||
if [ -z "$final_max_children" ] || [ "$final_max_children" -le 0 ]; then
|
||||
final_max_children="20"
|
||||
limiting_factor="Safe default (calculation failed)"
|
||||
fi
|
||||
|
||||
# Recommend pm mode
|
||||
local pm_result
|
||||
pm_result=$(recommend_pm_mode "$peak_concurrent" "$((peak_concurrent / 2))" "$stability_factor")
|
||||
local pm_mode min_spare max_spare pm_reason
|
||||
pm_mode=$(get_field "$pm_result" 1)
|
||||
min_spare=$(get_field "$pm_result" 2)
|
||||
max_spare=$(get_field "$pm_result" 3)
|
||||
pm_reason=$(get_field "$pm_result" 4)
|
||||
|
||||
# Return with detailed explanation
|
||||
local reason="3-constraint intelligent: Mem=$memory_based_max, Traffic=$traffic_based_max, Share=$fair_share_max → $limiting_factor"
|
||||
echo "$final_max_children|$pm_mode|$min_spare|$max_spare|$limiting_factor|$reason"
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# Export functions for use in other scripts
|
||||
# ============================================================================
|
||||
@@ -414,6 +647,10 @@ export -f calculate_max_children_memory_based
|
||||
export -f calculate_peak_concurrent_requests_improved
|
||||
export -f calculate_max_children_traffic_based
|
||||
export -f detect_mysql_memory_usage
|
||||
export -f calculate_server_capacity
|
||||
export -f get_domain_traffic_percentage
|
||||
export -f calculate_max_children_fair_share
|
||||
export -f recommend_pm_mode
|
||||
export -f calculate_optimal_php_settings
|
||||
export -f calculate_optimal_php_settings_intelligent
|
||||
export -f get_field
|
||||
|
||||
@@ -65,13 +65,29 @@ cecho " Scan Date: ${WHITE}$(date)${NC}"
|
||||
echo ""
|
||||
|
||||
# ============================================================================
|
||||
# DOMAIN ENUMERATION & ANALYSIS
|
||||
# STEP 1: CALCULATE SERVER CAPACITY
|
||||
# ============================================================================
|
||||
|
||||
cecho "${WHITE}${BOLD}DOMAIN-BY-DOMAIN ANALYSIS${NC}"
|
||||
cecho "${WHITE}${BOLD}STEP 1: SERVER CAPACITY ANALYSIS${NC}"
|
||||
cecho "${CYAN}─────────────────────────────────────────────────────────────────────${NC}"
|
||||
|
||||
server_capacity_result=$(calculate_server_capacity "$TOTAL_RAM_MB")
|
||||
server_capacity=$(echo "$server_capacity_result" | cut -d'|' -f1)
|
||||
available_memory=$(echo "$server_capacity_result" | cut -d'|' -f2)
|
||||
memory_per_process=$(echo "$server_capacity_result" | cut -d'|' -f3)
|
||||
|
||||
cecho " Available RAM for PHP-FPM: ${WHITE}${available_memory}MB${NC}"
|
||||
cecho " Memory per process: ${WHITE}${memory_per_process}MB${NC}"
|
||||
cecho " Server capacity: ${WHITE}${server_capacity}${NC} total max_children"
|
||||
echo ""
|
||||
|
||||
# ============================================================================
|
||||
# STEP 2: DOMAIN ENUMERATION & TRAFFIC ANALYSIS
|
||||
# ============================================================================
|
||||
|
||||
cecho "${WHITE}${BOLD}STEP 2: DOMAIN ENUMERATION & TRAFFIC ANALYSIS${NC}"
|
||||
cecho "${CYAN}─────────────────────────────────────────────────────────────────────${NC}"
|
||||
|
||||
# Get all users and domains
|
||||
users=$(list_all_users)
|
||||
|
||||
@@ -88,6 +104,8 @@ declare -a pm_max_requests
|
||||
declare -a pm_min_spare
|
||||
declare -a pm_max_spare
|
||||
declare -a pm_idle_timeout
|
||||
declare -a traffic_percentage_arr
|
||||
declare -a limiting_factor_arr
|
||||
|
||||
TOTAL_DOMAINS=0
|
||||
TOTAL_CURRENT_MEMORY=0
|
||||
@@ -137,11 +155,19 @@ while IFS= read -r username; do
|
||||
pm_idle=$(grep "^pm.process_idle_timeout = " "$pool_config" 2>/dev/null | awk -F'=' '{print $2}' | tr -d ' ')
|
||||
pm_idle_timeout[$TOTAL_DOMAINS]="${pm_idle:-10}"
|
||||
|
||||
# Calculate recommended using improved algorithm
|
||||
recommended_result=$(calculate_optimal_php_settings "$username" "$TOTAL_RAM_MB" 2>/dev/null || echo "20||")
|
||||
# Calculate recommended using THREE-CONSTRAINT INTELLIGENT ALGORITHM
|
||||
# Get traffic percentage for this domain
|
||||
traffic_percentage=$(get_domain_traffic_percentage "$username" "$domain" "$user_domains" 2>/dev/null | cut -d'|' -f1)
|
||||
traffic_percentage=${traffic_percentage:-50}
|
||||
|
||||
# Use intelligent three-constraint model: MIN(memory, traffic, fair_share)
|
||||
recommended_result=$(calculate_optimal_php_settings_intelligent "$username" "$TOTAL_RAM_MB" "$server_capacity" "$traffic_percentage" 2>/dev/null || echo "20|dynamic|1|5|ERROR|Failed")
|
||||
recommended=$(echo "$recommended_result" | cut -d'|' -f1)
|
||||
recommended=${recommended:-20}
|
||||
limiting_factor=$(echo "$recommended_result" | cut -d'|' -f5)
|
||||
recommended_max_children[$TOTAL_DOMAINS]="$recommended"
|
||||
traffic_percentage_arr[$TOTAL_DOMAINS]="$traffic_percentage"
|
||||
limiting_factor_arr[$TOTAL_DOMAINS]="$limiting_factor"
|
||||
|
||||
# Calculate memory impact (assuming 20MB per process on average)
|
||||
current_memory=$((current * 20))
|
||||
@@ -261,7 +287,8 @@ for idx in "${sorted_indices[@]}"; do
|
||||
if [ "$optimize" == "YES" ]; then
|
||||
cecho "${YELLOW}[$idx]${NC} $domain"
|
||||
cecho " Owner: $owner"
|
||||
cecho " Traffic: $traffic_indicator"
|
||||
cecho " Traffic: $traffic_indicator (${traffic_percentage_arr[$idx]}% of server)"
|
||||
cecho " Limiting Factor: ${limiting_factor_arr[$idx]}"
|
||||
cecho ""
|
||||
cecho " ${BOLD}Current Pool Settings:${NC}"
|
||||
cecho " pm.max_children: ${RED}$current${NC} → Recommended: ${GREEN}$recommended${NC}"
|
||||
|
||||
@@ -2459,7 +2459,16 @@ optimize_level_5_everything() {
|
||||
echo ""
|
||||
fi
|
||||
|
||||
cecho "${CYAN}STEP 2: Calculating Recommendations${NC}"
|
||||
cecho "${CYAN}STEP 2: Calculating Intelligent Recommendations${NC}"
|
||||
echo ""
|
||||
|
||||
# Calculate server capacity for fair share allocation
|
||||
local server_capacity_result
|
||||
server_capacity_result=$(calculate_server_capacity "$TOTAL_RAM_MB")
|
||||
local server_capacity
|
||||
server_capacity=$(echo "$server_capacity_result" | cut -d'|' -f1)
|
||||
cecho " Server PHP-FPM capacity: ${WHITE}${server_capacity}${NC} max_children"
|
||||
cecho " Using three-constraint model: Memory + Traffic + Fair Share"
|
||||
echo ""
|
||||
|
||||
# Check if profiles exist
|
||||
@@ -2502,24 +2511,30 @@ optimize_level_5_everything() {
|
||||
current_max="?"
|
||||
fi
|
||||
|
||||
# Get recommendations - use profile if available, otherwise use traffic-based
|
||||
# Get recommendations using THREE-CONSTRAINT INTELLIGENT MODEL
|
||||
local recommended_max
|
||||
local recommended_memory
|
||||
local recommended_requests
|
||||
local traffic_pct=50 # Default if no data
|
||||
|
||||
# Get traffic percentage for this domain
|
||||
if [ "$profiles_exist" = "1" ] && [ -f "/tmp/php-domain-profiles/$domain.profile" ]; then
|
||||
# Use profile data if available
|
||||
recommended_max=$(get_max_children_recommendation "$domain" "$username")
|
||||
recommended_memory=$(get_memory_limit_recommendation "$domain" "$username")
|
||||
recommended_requests=$(get_max_requests_recommendation "$domain")
|
||||
else
|
||||
# Fallback to traffic-based (old method)
|
||||
local traffic_rpm
|
||||
traffic_rpm=$(get_domain_peak_concurrent "$domain" 2>/dev/null || echo "0")
|
||||
[ "$traffic_rpm" = "?" ] && traffic_rpm="0"
|
||||
# Use intelligent three-constraint model
|
||||
traffic_pct=$(get_domain_traffic_percentage "$username" "$domain" "$user_domains" 2>/dev/null | cut -d'|' -f1)
|
||||
traffic_pct=${traffic_pct:-50}
|
||||
|
||||
recommended_max=$((traffic_rpm > 5 ? traffic_rpm + 10 : 5))
|
||||
recommended_memory=$(calculate_optimal_memory_limit "$username" "$domain" "$traffic_rpm")
|
||||
recommended_requests=$(calculate_optimal_max_requests "$traffic_rpm")
|
||||
# Call intelligent three-constraint function
|
||||
local intel_result
|
||||
intel_result=$(calculate_optimal_php_settings_intelligent "$username" "$TOTAL_RAM_MB" "$server_capacity" "$traffic_pct" 2>/dev/null || echo "20|dynamic|1|5|ERROR|Failed")
|
||||
|
||||
recommended_max=$(echo "$intel_result" | cut -d'|' -f1)
|
||||
recommended_memory=$(calculate_optimal_memory_limit "$username" "$domain" "$recommended_max" 2>/dev/null || echo "128M")
|
||||
recommended_requests=$(calculate_optimal_max_requests "$recommended_max" 2>/dev/null || echo "0")
|
||||
fi
|
||||
|
||||
recommended_max_children["$domain"]="$recommended_max"
|
||||
|
||||
Reference in New Issue
Block a user