mirror of
https://github.com/usmannasir/cyberpanel.git
synced 2025-11-05 21:05:46 +01:00
657 lines
29 KiB
Python
657 lines
29 KiB
Python
import os.path
|
|
|
|
from plogical.processUtilities import ProcessUtilities
|
|
import json
|
|
import re
|
|
from django.shortcuts import HttpResponse
|
|
from random import randint
|
|
from .models import *
|
|
from xml.etree import ElementTree
|
|
|
|
class PHPManager:
|
|
|
|
@staticmethod
|
|
def findPHPVersions():
|
|
"""
|
|
Comprehensive PHP version detection that checks multiple locations and methods
|
|
"""
|
|
try:
|
|
finalPHPVersions = []
|
|
|
|
# Method 1: Check /usr/local/lsws directory (LiteSpeed PHP)
|
|
try:
|
|
result = ProcessUtilities.outputExecutioner('ls -la /usr/local/lsws')
|
|
lsphp_lines = [line for line in result.split('\n') if 'lsphp' in line]
|
|
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Found PHP lines in findPHPVersions: {lsphp_lines}')
|
|
|
|
# Parse lsphp directories
|
|
for line in lsphp_lines:
|
|
try:
|
|
parts = line.split()
|
|
if len(parts) >= 9:
|
|
for part in parts:
|
|
if part.startswith('lsphp') and part != 'lsphp':
|
|
version_part = part[5:] # Remove 'lsphp' prefix
|
|
if len(version_part) >= 2:
|
|
major = version_part[0]
|
|
minor = version_part[1:]
|
|
formatted_version = f'PHP {major}.{minor}'
|
|
|
|
# Validate the PHP installation
|
|
phpString = PHPManager.getPHPString(formatted_version)
|
|
php_path = f"/usr/local/lsws/lsphp{phpString}/bin/php"
|
|
lsphp_path = f"/usr/local/lsws/lsphp{phpString}/bin/lsphp"
|
|
|
|
if os.path.exists(php_path) or os.path.exists(lsphp_path):
|
|
if formatted_version not in finalPHPVersions:
|
|
finalPHPVersions.append(formatted_version)
|
|
except (IndexError, ValueError):
|
|
continue
|
|
except Exception as e:
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error checking /usr/local/lsws: {str(e)}')
|
|
|
|
# Method 2: Check system-wide PHP installations
|
|
try:
|
|
# Check for system PHP versions
|
|
system_php_versions = ['7.4', '8.0', '8.1', '8.2', '8.3', '8.4', '8.5']
|
|
for version in system_php_versions:
|
|
formatted_version = f'PHP {version}'
|
|
if formatted_version not in finalPHPVersions:
|
|
# Check if this version exists in system
|
|
try:
|
|
phpString = PHPManager.getPHPString(formatted_version)
|
|
php_path = f"/usr/local/lsws/lsphp{phpString}/bin/php"
|
|
lsphp_path = f"/usr/local/lsws/lsphp{phpString}/bin/lsphp"
|
|
|
|
if os.path.exists(php_path) or os.path.exists(lsphp_path):
|
|
finalPHPVersions.append(formatted_version)
|
|
except:
|
|
continue
|
|
except Exception as e:
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error checking system PHP: {str(e)}')
|
|
|
|
# Method 3: Check package manager for available PHP versions
|
|
try:
|
|
# Try to detect available PHP packages
|
|
if ProcessUtilities.decideDistro() in [ProcessUtilities.centos, ProcessUtilities.cent8]:
|
|
# For CentOS/RHEL/AlmaLinux
|
|
command = "yum list available | grep lsphp | grep -E 'lsphp[0-9]+' | head -20"
|
|
else:
|
|
# For Ubuntu/Debian
|
|
command = "apt list --installed | grep lsphp | grep -E 'lsphp[0-9]+' | head -20"
|
|
|
|
result = ProcessUtilities.outputExecutioner(command)
|
|
if result and result.strip():
|
|
for line in result.split('\n'):
|
|
if 'lsphp' in line:
|
|
# Extract version from package name
|
|
import re
|
|
match = re.search(r'lsphp(\d+)(\d+)', line)
|
|
if match:
|
|
major = match.group(1)
|
|
minor = match.group(2)
|
|
formatted_version = f'PHP {major}.{minor}'
|
|
|
|
if formatted_version not in finalPHPVersions:
|
|
# Validate installation
|
|
try:
|
|
phpString = PHPManager.getPHPString(formatted_version)
|
|
php_path = f"/usr/local/lsws/lsphp{phpString}/bin/php"
|
|
lsphp_path = f"/usr/local/lsws/lsphp{phpString}/bin/lsphp"
|
|
|
|
if os.path.exists(php_path) or os.path.exists(lsphp_path):
|
|
finalPHPVersions.append(formatted_version)
|
|
except:
|
|
continue
|
|
except Exception as e:
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error checking package manager: {str(e)}')
|
|
|
|
# Method 4: Fallback to checking common PHP versions
|
|
if not finalPHPVersions:
|
|
fallback_versions = ['PHP 7.4', 'PHP 8.0', 'PHP 8.1', 'PHP 8.2', 'PHP 8.3', 'PHP 8.4', 'PHP 8.5']
|
|
for version in fallback_versions:
|
|
try:
|
|
phpString = PHPManager.getPHPString(version)
|
|
php_path = f"/usr/local/lsws/lsphp{phpString}/bin/php"
|
|
lsphp_path = f"/usr/local/lsws/lsphp{phpString}/bin/lsphp"
|
|
if os.path.exists(php_path) or os.path.exists(lsphp_path):
|
|
finalPHPVersions.append(version)
|
|
except:
|
|
continue
|
|
|
|
# Sort versions (newest first)
|
|
def version_sort_key(version):
|
|
try:
|
|
# Extract version number for sorting
|
|
version_num = version.replace('PHP ', '').split('.')
|
|
major = int(version_num[0])
|
|
minor = int(version_num[1]) if len(version_num) > 1 else 0
|
|
return (major, minor)
|
|
except:
|
|
return (0, 0)
|
|
|
|
finalPHPVersions.sort(key=version_sort_key, reverse=True)
|
|
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Final PHP versions found: {finalPHPVersions}')
|
|
|
|
return finalPHPVersions if finalPHPVersions else ['PHP 7.4', 'PHP 8.0', 'PHP 8.1', 'PHP 8.2', 'PHP 8.3', 'PHP 8.4', 'PHP 8.5']
|
|
|
|
except BaseException as msg:
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error while finding php versions on system: {str(msg)}')
|
|
return ['PHP 7.4', 'PHP 8.0', 'PHP 8.1', 'PHP 8.2', 'PHP 8.3', 'PHP 8.4', 'PHP 8.5']
|
|
|
|
@staticmethod
|
|
def findApachePHPVersions():
|
|
# distro = ProcessUtilities.decideDistro()
|
|
# if distro == ProcessUtilities.centos:
|
|
# return ['PHP 5.3', 'PHP 5.4', 'PHP 5.5', 'PHP 5.6', 'PHP 7.0', 'PHP 7.1', 'PHP 7.2', 'PHP 7.3', 'PHP 7.4', 'PHP 8.0', 'PHP 8.1']
|
|
# elif distro == ProcessUtilities.cent8:
|
|
# return ['PHP 7.1','PHP 7.2', 'PHP 7.3', 'PHP 7.4', 'PHP 8.0', 'PHP 8.1']
|
|
# elif distro == ProcessUtilities.ubuntu20:
|
|
# return ['PHP 7.2', 'PHP 7.3', 'PHP 7.4', 'PHP 8.0', 'PHP 8.1']
|
|
# else:
|
|
# return ['PHP 7.0', 'PHP 7.1', 'PHP 7.2', 'PHP 7.3', 'PHP 7.4', 'PHP 8.0', 'PHP 8.1', 'PHP 8.2', 'PHP 8.3', 'PHP 8.4', 'PHP 8.5']
|
|
|
|
try:
|
|
|
|
# Run the shell command and capture the output
|
|
from ApachController.ApacheController import ApacheController as ApachController
|
|
result = ProcessUtilities.outputExecutioner(f'ls -la {ApachController.phpBasepath}')
|
|
|
|
if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
|
|
|
|
# Get the lines containing 'lsphp' in the output
|
|
lsphp_lines = [line for line in result.split('\n') if 'php' in line]
|
|
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Found PHP lines in findApachePHPVersions: {lsphp_lines}')
|
|
|
|
# Extract the version from the lines and format it as 'PHP x.y'
|
|
# Extract and format PHP versions
|
|
php_versions = []
|
|
for entry in lsphp_lines:
|
|
# Find substring starting with 'php' and extract the version part
|
|
version = entry.split('php')[1]
|
|
# Format version as PHP X.Y
|
|
formatted_version = f"PHP {version[0]}.{version[1]}"
|
|
php_versions.append(formatted_version)
|
|
else:
|
|
|
|
lsphp_lines = [line for line in result.split('\n')]
|
|
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Found PHP lines in findApachePHPVersions: {lsphp_lines}')
|
|
|
|
# Extract the version from the lines and format it as 'PHP x.y'
|
|
# Extract and format PHP versions
|
|
php_versions = []
|
|
for entry in lsphp_lines:
|
|
# Find substring starting with 'php' and extract the version part
|
|
try:
|
|
version = entry.split('.')
|
|
# Format version as PHP X.Y
|
|
formatted_version = f"PHP {version[-2][-1]}.{version[-1]}"
|
|
if formatted_version != 'PHP .':
|
|
php_versions.append(formatted_version)
|
|
except:
|
|
pass
|
|
|
|
|
|
|
|
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Found PHP versions in findApachePHPVersions: {php_versions}')
|
|
|
|
# Now php_versions contains the formatted PHP versions
|
|
return php_versions
|
|
except BaseException as msg:
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error while finding php versions on system: {str(msg)}')
|
|
return ['PHP 7.0', 'PHP 7.1', 'PHP 7.2', 'PHP 7.3', 'PHP 7.4', 'PHP 8.0', 'PHP 8.1', 'PHP 8.2', 'PHP 8.3', 'PHP 8.4', 'PHP 8.5']
|
|
|
|
@staticmethod
|
|
def getPHPString(phpVersion):
|
|
# Ex: "PHP 5.3" type string, return Ex: "53" type string
|
|
phpVersion = phpVersion.split()
|
|
php = phpVersion[1].replace(".", "")
|
|
|
|
return php
|
|
|
|
@staticmethod
|
|
def validatePHPInstallation(phpVersion):
|
|
"""
|
|
Validate that a PHP installation is properly configured and accessible
|
|
Returns: (is_valid, error_message, php_path)
|
|
"""
|
|
try:
|
|
php = PHPManager.getPHPString(phpVersion)
|
|
php_path = f'/usr/local/lsws/lsphp{php}/bin/php'
|
|
lsphp_path = f'/usr/local/lsws/lsphp{php}/bin/lsphp'
|
|
|
|
# Check if PHP binary exists
|
|
if os.path.exists(php_path):
|
|
return True, None, php_path
|
|
elif os.path.exists(lsphp_path):
|
|
return True, None, lsphp_path
|
|
else:
|
|
# Try alternative locations
|
|
alternative_paths = [
|
|
f'/usr/local/lsws/lsphp{php}/bin/lsphp',
|
|
'/usr/bin/php',
|
|
'/usr/local/bin/php'
|
|
]
|
|
|
|
for alt_path in alternative_paths:
|
|
if os.path.exists(alt_path):
|
|
return True, None, alt_path
|
|
|
|
return False, f'PHP {phpVersion} binary not found. Please install or check PHP installation.', None
|
|
|
|
except Exception as e:
|
|
return False, f'Error validating PHP installation: {str(e)}', None
|
|
|
|
@staticmethod
|
|
def fixPHPConfiguration(phpVersion):
|
|
"""
|
|
Attempt to fix common PHP configuration issues
|
|
"""
|
|
try:
|
|
php = PHPManager.getPHPString(phpVersion)
|
|
php_dir = f'/usr/local/lsws/lsphp{php}'
|
|
|
|
# Check if PHP directory exists
|
|
if not os.path.exists(php_dir):
|
|
return False, f'PHP directory {php_dir} does not exist'
|
|
|
|
# Check for missing php binary and create symlink if needed
|
|
php_binary = f'{php_dir}/bin/php'
|
|
lsphp_binary = f'{php_dir}/bin/lsphp'
|
|
|
|
if not os.path.exists(php_binary) and os.path.exists(lsphp_binary):
|
|
# Create symlink from lsphp to php
|
|
import subprocess
|
|
subprocess.run(['ln', '-sf', 'lsphp', 'php'], cwd=f'{php_dir}/bin')
|
|
return True, 'PHP binary symlink created successfully'
|
|
|
|
return True, 'PHP configuration appears to be correct'
|
|
|
|
except Exception as e:
|
|
return False, f'Error fixing PHP configuration: {str(e)}'
|
|
|
|
@staticmethod
|
|
def getLatestPHPVersion():
|
|
"""
|
|
Get the latest available PHP version from the system
|
|
Returns: (latest_version, all_versions)
|
|
"""
|
|
try:
|
|
all_versions = PHPManager.findPHPVersions()
|
|
|
|
if not all_versions:
|
|
return None, []
|
|
|
|
# Sort versions to get the latest
|
|
def version_sort_key(version):
|
|
try:
|
|
version_num = version.replace('PHP ', '').split('.')
|
|
major = int(version_num[0])
|
|
minor = int(version_num[1]) if len(version_num) > 1 else 0
|
|
return (major, minor)
|
|
except:
|
|
return (0, 0)
|
|
|
|
sorted_versions = sorted(all_versions, key=version_sort_key, reverse=True)
|
|
latest_version = sorted_versions[0]
|
|
|
|
return latest_version, all_versions
|
|
|
|
except Exception as e:
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error getting latest PHP version: {str(e)}')
|
|
return None, []
|
|
|
|
@staticmethod
|
|
def getRecommendedPHPVersion():
|
|
"""
|
|
Get the recommended PHP version for new installations
|
|
Priority: 8.3 (recommended), 8.2, 8.4, 8.5, 8.1, 8.0, 7.4
|
|
"""
|
|
try:
|
|
all_versions = PHPManager.findPHPVersions()
|
|
|
|
if not all_versions:
|
|
return 'PHP 8.3' # Default recommendation
|
|
|
|
# Priority order for recommendations
|
|
recommended_order = ['PHP 8.3', 'PHP 8.2', 'PHP 8.4', 'PHP 8.5', 'PHP 8.1', 'PHP 8.0', 'PHP 7.4']
|
|
|
|
for recommended in recommended_order:
|
|
if recommended in all_versions:
|
|
return recommended
|
|
|
|
# If none of the recommended versions are available, return the latest
|
|
latest, _ = PHPManager.getLatestPHPVersion()
|
|
return latest if latest else 'PHP 8.3'
|
|
|
|
except Exception as e:
|
|
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
|
|
logging.writeToFile(f'Error getting recommended PHP version: {str(e)}')
|
|
return 'PHP 8.3'
|
|
|
|
@staticmethod
|
|
def FindPHPFPMPath(phpVersion):
|
|
if phpVersion == "PHP 5.3":
|
|
return "/opt/remi/php54/root/etc/php.ini"
|
|
elif phpVersion == "PHP 5.4":
|
|
return "/opt/remi/php54/root/etc/php.ini"
|
|
elif phpVersion == "PHP 5.5":
|
|
return "/opt/remi/php55/root/etc/php.ini"
|
|
elif phpVersion == "PHP 5.6":
|
|
return "/etc/opt/remi/php56/php.ini"
|
|
elif phpVersion == "PHP 7.0":
|
|
return "/etc/opt/remi/php70/php.ini"
|
|
elif phpVersion == "PHP 7.1":
|
|
return "/etc/opt/remi/php71/php.ini"
|
|
elif phpVersion == "PHP 7.2":
|
|
return "/etc/opt/remi/php72/php.ini"
|
|
elif phpVersion == "PHP 7.3":
|
|
return "/etc/opt/remi/php73/php.ini"
|
|
|
|
|
|
@staticmethod
|
|
def getCurrentPHPConfig(phpVersion):
|
|
allow_url_fopen = "0"
|
|
display_errors = "0"
|
|
file_uploads = "0"
|
|
allow_url_include = "0"
|
|
memory_limit = ""
|
|
max_execution_time = ""
|
|
upload_max_filesize = ""
|
|
max_input_time = ""
|
|
|
|
command = "cat " + PHPManager.FindPHPFPMPath(phpVersion)
|
|
|
|
data = ProcessUtilities.outputExecutioner(command).split('\n')
|
|
|
|
for items in data:
|
|
if items.find("allow_url_fopen") > -1 and items.find("=") > -1:
|
|
if items.find("On") > -1:
|
|
allow_url_fopen = "1"
|
|
if items.find("display_errors") > -1 and items.find("=") > -1:
|
|
if items.find("On") > -1:
|
|
display_errors = "1"
|
|
if items.find("file_uploads") > -1 and items.find("=") > -1:
|
|
if items.find("On") > -1:
|
|
file_uploads = "1"
|
|
if items.find("allow_url_include") > -1 and items.find("=") > -1:
|
|
if items.find("On") > -1:
|
|
allow_url_include = "1"
|
|
if items.find("memory_limit") > -1 and items.find("=") > -1:
|
|
memory_limit = re.findall(r"[A-Za-z0-9_]+", items)[1]
|
|
if items.find("max_execution_time") > -1 and items.find("=") > -1:
|
|
max_execution_time = re.findall(r"[A-Za-z0-9_]+", items)[1]
|
|
if items.find("upload_max_filesize") > -1 and items.find("=") > -1:
|
|
upload_max_filesize = re.findall(r"[A-Za-z0-9_]+", items)[1]
|
|
if items.find("max_input_time") > -1 and items.find("=") > -1:
|
|
max_input_time = re.findall(r"[A-Za-z0-9_]+", items)[1]
|
|
if items.find("post_max_size") > -1 and items.find("=") > -1:
|
|
post_max_size = re.findall(r"[A-Za-z0-9_]+", items)[1]
|
|
|
|
final_dic = {'fetchStatus': 1,
|
|
'allow_url_fopen': allow_url_fopen,
|
|
'display_errors': display_errors,
|
|
'file_uploads': file_uploads,
|
|
'allow_url_include': allow_url_include,
|
|
'memory_limit': memory_limit,
|
|
'max_execution_time': max_execution_time,
|
|
'upload_max_filesize': upload_max_filesize,
|
|
'max_input_time': max_input_time,
|
|
'post_max_size': post_max_size,
|
|
'status': 1}
|
|
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
|
|
@staticmethod
|
|
def savePHPConfigBasic(data):
|
|
phpVersion = data['phpVersion']
|
|
allow_url_fopen = data['allow_url_fopen']
|
|
display_errors = data['display_errors']
|
|
file_uploads = data['file_uploads']
|
|
allow_url_include = data['allow_url_include']
|
|
memory_limit = data['memory_limit']
|
|
max_execution_time = data['max_execution_time']
|
|
upload_max_filesize = data['upload_max_filesize']
|
|
max_input_time = data['max_input_time']
|
|
post_max_size = data['post_max_size']
|
|
|
|
if allow_url_fopen:
|
|
allow_url_fopen = "allow_url_fopen = On"
|
|
else:
|
|
allow_url_fopen = "allow_url_fopen = Off"
|
|
|
|
if display_errors:
|
|
display_errors = "display_errors = On"
|
|
else:
|
|
display_errors = "display_errors = Off"
|
|
|
|
if file_uploads:
|
|
file_uploads = "file_uploads = On"
|
|
else:
|
|
file_uploads = "file_uploads = Off"
|
|
|
|
if allow_url_include:
|
|
allow_url_include = "allow_url_include = On"
|
|
else:
|
|
allow_url_include = "allow_url_include = Off"
|
|
|
|
path = PHPManager.FindPHPFPMPath(phpVersion)
|
|
command = "cat " + path
|
|
data = ProcessUtilities.outputExecutioner(command).splitlines()
|
|
|
|
tempStatusPath = "/home/cyberpanel/" + str(randint(1000, 9999))
|
|
|
|
writeToFile = open(tempStatusPath, 'w')
|
|
|
|
# Track which directives we've found and replaced
|
|
found_directives = {
|
|
'allow_url_fopen': False,
|
|
'display_errors': False,
|
|
'file_uploads': False,
|
|
'allow_url_include': False,
|
|
'memory_limit': False,
|
|
'max_execution_time': False,
|
|
'upload_max_filesize': False,
|
|
'max_input_time': False,
|
|
'post_max_size': False
|
|
}
|
|
|
|
for items in data:
|
|
if items.find("allow_url_fopen") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines(allow_url_fopen + "\n")
|
|
found_directives['allow_url_fopen'] = True
|
|
elif items.find("display_errors") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines(display_errors + "\n")
|
|
found_directives['display_errors'] = True
|
|
elif items.find("file_uploads") > -1 and items.find("=") > -1 and not items.find(
|
|
"max_file_uploads") > -1:
|
|
writeToFile.writelines(file_uploads + "\n")
|
|
found_directives['file_uploads'] = True
|
|
elif items.find("allow_url_include") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines(allow_url_include + "\n")
|
|
found_directives['allow_url_include'] = True
|
|
elif items.find("memory_limit") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines("memory_limit = " + memory_limit + "\n")
|
|
found_directives['memory_limit'] = True
|
|
elif items.find("max_execution_time") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines("max_execution_time = " + max_execution_time + "\n")
|
|
found_directives['max_execution_time'] = True
|
|
elif items.find("upload_max_filesize") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines("upload_max_filesize = " + upload_max_filesize + "\n")
|
|
found_directives['upload_max_filesize'] = True
|
|
elif items.find("max_input_time") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines("max_input_time = " + max_input_time + "\n")
|
|
found_directives['max_input_time'] = True
|
|
elif items.find("post_max_size") > -1 and items.find("=") > -1:
|
|
writeToFile.writelines("post_max_size = " + post_max_size + "\n")
|
|
found_directives['post_max_size'] = True
|
|
else:
|
|
writeToFile.writelines(items + '\n')
|
|
|
|
# Add any missing directives at the end of the file
|
|
missing_directives = []
|
|
if not found_directives['allow_url_fopen']:
|
|
missing_directives.append(allow_url_fopen)
|
|
if not found_directives['display_errors']:
|
|
missing_directives.append(display_errors)
|
|
if not found_directives['file_uploads']:
|
|
missing_directives.append(file_uploads)
|
|
if not found_directives['allow_url_include']:
|
|
missing_directives.append(allow_url_include)
|
|
if not found_directives['memory_limit']:
|
|
missing_directives.append("memory_limit = " + memory_limit)
|
|
if not found_directives['max_execution_time']:
|
|
missing_directives.append("max_execution_time = " + max_execution_time)
|
|
if not found_directives['upload_max_filesize']:
|
|
missing_directives.append("upload_max_filesize = " + upload_max_filesize)
|
|
if not found_directives['max_input_time']:
|
|
missing_directives.append("max_input_time = " + max_input_time)
|
|
if not found_directives['post_max_size']:
|
|
missing_directives.append("post_max_size = " + post_max_size)
|
|
|
|
if missing_directives:
|
|
writeToFile.writelines("\n; Added by CyberPanel PHP Config Manager\n")
|
|
for directive in missing_directives:
|
|
writeToFile.writelines(directive + "\n")
|
|
|
|
writeToFile.close()
|
|
|
|
command = "mv %s %s" % (tempStatusPath, path)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
php = PHPManager.getPHPString(phpVersion)
|
|
|
|
command = "systemctl stop php%s-php-fpm" % (php)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
command = "systemctl start php%s-php-fpm" % (php)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
final_dic = {'status': 1}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
@staticmethod
|
|
def fetchPHPSettingsAdvance(phpVersion):
|
|
command = "cat " + PHPManager.FindPHPFPMPath(phpVersion)
|
|
data = ProcessUtilities.outputExecutioner(command)
|
|
final_dic = {'fetchStatus': 1,
|
|
'configData': data,
|
|
'status': 1}
|
|
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
|
|
@staticmethod
|
|
def savePHPConfigAdvance(data):
|
|
phpVersion = data['phpVersion']
|
|
configData = data['configData']
|
|
|
|
path = PHPManager.FindPHPFPMPath(phpVersion)
|
|
|
|
tempStatusPath = "/home/cyberpanel/" + str(randint(1000, 9999))
|
|
|
|
writeToFile = open(tempStatusPath, 'w')
|
|
writeToFile.write(configData)
|
|
writeToFile.close()
|
|
|
|
command = "mv %s %s" % (tempStatusPath, path)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
php = PHPManager.getPHPString(phpVersion)
|
|
|
|
command = "systemctl stop php%s-php-fpm" % (php)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
command = "systemctl start php%s-php-fpm" % (php)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
final_dic = {'status': 1}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
@staticmethod
|
|
def fetchPHPExtensions(data):
|
|
|
|
if ApachePHP.objects.all().count() == 0:
|
|
phpfilePath = '/usr/local/CyberCP/ApachController/phpApache.xml'
|
|
|
|
for items in ['54', '55', '56', '70', '71', '72', '73']:
|
|
phpvers = ApachePHP(phpVers='php' + items)
|
|
phpvers.save()
|
|
|
|
php = ElementTree.parse(phpfilePath)
|
|
phpExtensions = php.findall('extension')
|
|
|
|
for extension in phpExtensions:
|
|
extensionName = extension.find('extensionName').text % (items)
|
|
extensionDescription = extension.find('extensionDescription').text
|
|
status = int(extension.find('status').text)
|
|
|
|
phpExtension = installedPackagesApache(phpVers=phpvers,
|
|
extensionName=extensionName,
|
|
description=extensionDescription,
|
|
status=status)
|
|
|
|
phpExtension.save()
|
|
|
|
phpVers = "php" + PHPManager.getPHPString(data['phpVersion'])
|
|
|
|
phpVersion = ApachePHP.objects.get(phpVers=phpVers)
|
|
|
|
records = phpVersion.installedpackagesapache_set.all()
|
|
|
|
json_data = "["
|
|
checker = 0
|
|
|
|
for items in records:
|
|
|
|
if items.status == 0:
|
|
status = "Not-Installed"
|
|
else:
|
|
status = "Installed"
|
|
|
|
dic = {'id': items.id,
|
|
'phpVers': items.phpVers.phpVers,
|
|
'extensionName': items.extensionName,
|
|
'description': items.description,
|
|
'status': status
|
|
}
|
|
|
|
if checker == 0:
|
|
json_data = json_data + json.dumps(dic)
|
|
checker = 1
|
|
else:
|
|
json_data = json_data + ',' + json.dumps(dic)
|
|
|
|
json_data = json_data + ']'
|
|
final_json = json.dumps({'status': 1, 'error_message': "None", "data": json_data})
|
|
return HttpResponse(final_json)
|