mirror of
https://github.com/usmannasir/cyberpanel.git
synced 2025-10-31 02:15:55 +01:00
05bcb46fd6
- Removed local installation function in favor of a direct installation approach. - Updated installation script to prioritize the development branch for downloading CyberPanel, with a fallback to stable if unavailable. - Adjusted PHP version lists across various scripts to exclude PHP 8.6 and ensure compatibility with existing versions. - Enhanced error handling and feedback during installation to improve user experience.
524 lines
21 KiB
Python
524 lines
21 KiB
Python
import sys
|
|
sys.path.append('/usr/local/CyberCP')
|
|
from plogical import CyberCPLogFileWriter as logging
|
|
import subprocess
|
|
import shlex
|
|
import _thread
|
|
from plogical import installUtilities
|
|
import argparse
|
|
import os
|
|
from plogical.mailUtilities import mailUtilities
|
|
from plogical.processUtilities import ProcessUtilities
|
|
from ApachController.ApacheVhosts import ApacheVhost
|
|
|
|
import json
|
|
from django.urls import reverse
|
|
|
|
class phpUtilities:
|
|
|
|
installLogPath = "/home/cyberpanel/phpExtensionRequestLog"
|
|
|
|
@staticmethod
|
|
def installPHPExtension(extension,extensions):
|
|
try:
|
|
|
|
mailUtilities.checkHome()
|
|
|
|
if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
|
|
command = 'sudo yum install ' + extension + ' -y'
|
|
else:
|
|
command = 'sudo apt-get install ' + extension + ' -y'
|
|
|
|
cmd = shlex.split(command)
|
|
|
|
try:
|
|
with open(phpUtilities.installLogPath, 'w') as f:
|
|
subprocess.call(cmd, stdout=f)
|
|
|
|
writeToFile = open(phpUtilities.installLogPath, 'a')
|
|
writeToFile.writelines("PHP Extension Installed.\n")
|
|
writeToFile.close()
|
|
|
|
installUtilities.installUtilities.reStartLiteSpeed()
|
|
|
|
return 1
|
|
except:
|
|
writeToFile = open(phpUtilities.installLogPath, 'a')
|
|
writeToFile.writelines("Can not be installed.\n")
|
|
writeToFile.close()
|
|
logging.CyberCPLogFileWriter.writeToFile("[Could not Install]")
|
|
installUtilities.installUtilities.reStartLiteSpeed()
|
|
return 0
|
|
except BaseException as msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + "[installPHPExtension]")
|
|
|
|
@staticmethod
|
|
def unInstallPHPExtension(extension,extensions):
|
|
try:
|
|
|
|
mailUtilities.checkHome()
|
|
|
|
if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
|
|
command = 'sudo rpm --nodeps -e ' + extension + ' -v'
|
|
else:
|
|
command = 'sudo apt-get remove -y ' + extension
|
|
|
|
cmd = shlex.split(command)
|
|
|
|
try:
|
|
|
|
with open(phpUtilities.installLogPath, 'w') as f:
|
|
subprocess.call(cmd, stdout=f)
|
|
|
|
writeToFile = open(phpUtilities.installLogPath, 'a')
|
|
writeToFile.writelines("PHP Extension Removed.\n")
|
|
writeToFile.close()
|
|
installUtilities.installUtilities.reStartLiteSpeed()
|
|
return 1
|
|
except:
|
|
writeToFile = open(phpUtilities.installLogPath, 'a')
|
|
writeToFile.writelines("Can not un-install Extension.\n")
|
|
writeToFile.close()
|
|
logging.CyberCPLogFileWriter.writeToFile("[Could not Install]")
|
|
installUtilities.installUtilities.reStartLiteSpeed()
|
|
return 0
|
|
|
|
except BaseException as msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + "[unInstallPHPExtension]")
|
|
|
|
@staticmethod
|
|
def initiateInstall(extension):
|
|
try:
|
|
_thread.start_new_thread(phpUtilities.installPHPExtension, (extension, extension))
|
|
except BaseException as msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [initiateInstall]")
|
|
|
|
@staticmethod
|
|
def initiateRemoval(extension):
|
|
try:
|
|
_thread.start_new_thread(phpUtilities.unInstallPHPExtension, (extension, extension))
|
|
except BaseException as msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [initiateRestore]")
|
|
|
|
@staticmethod
|
|
def savePHPConfigBasic(phpVers,allow_url_fopen,display_errors,file_uploads,allow_url_include,memory_limit,max_execution_time,upload_max_filesize,max_input_time,post_max_size, apache):
|
|
try:
|
|
serverLevelPHPRestart = '/usr/local/lsws/admin/tmp/.lsphp_restart.txt'
|
|
|
|
|
|
command = 'touch %s' % (serverLevelPHPRestart)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
from ApachController.ApacheVhosts import ApacheVhost
|
|
path = ApacheVhost.DecidePHPPathforManager(int(apache), phpVers)
|
|
|
|
data = open(path, 'r').readlines()
|
|
|
|
writeToFile = open(path, '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)
|
|
|
|
# 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()
|
|
|
|
installUtilities.installUtilities.reStartLiteSpeed()
|
|
|
|
if int(apache) == 1:
|
|
|
|
phpService = ApacheVhost.DecideFPMServiceName(phpVers)
|
|
|
|
command = f"systemctl restart {phpService}"
|
|
ProcessUtilities.normalExecutioner(command)
|
|
|
|
print("1,None")
|
|
|
|
except BaseException as msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(
|
|
str(msg) + " [savePHPConfigBasic]")
|
|
print("0,"+str(msg))
|
|
|
|
@staticmethod
|
|
def savePHPConfigAdvance(phpVers,tempPath):
|
|
try:
|
|
|
|
serverLevelPHPRestart = '/usr/local/lsws/admin/tmp/.lsphp_restart.txt'
|
|
command = 'touch %s' % (serverLevelPHPRestart)
|
|
ProcessUtilities.executioner(command)
|
|
|
|
phpINI = open(phpVers, 'w')
|
|
phpINI.write(open(tempPath, "r").read())
|
|
phpINI.close()
|
|
|
|
if os.path.exists(serverLevelPHPRestart):
|
|
os.remove(serverLevelPHPRestart)
|
|
|
|
installUtilities.installUtilities.reStartLiteSpeed()
|
|
|
|
if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
|
|
phpService = f'php{phpVers}-php-fpm'
|
|
else:
|
|
phpService = f"php{phpVers.split('/')[3]}-fpm"
|
|
|
|
command = f"systemctl restart {phpService}"
|
|
ProcessUtilities.normalExecutioner(command)
|
|
|
|
print("1,None")
|
|
except BaseException as msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(
|
|
str(msg) + " [savePHPConfigAdvance]")
|
|
print("0,"+str(msg))
|
|
|
|
@staticmethod
|
|
def GetStagingInJson(stagings):
|
|
try:
|
|
|
|
json_data = "["
|
|
checker = 0
|
|
counter = 1
|
|
|
|
for staging in stagings:
|
|
dic = { 'id': staging.wpsite.id ,'name': staging.wpsite.title, 'Domain': staging.wpsite.owner.domain, 'path': staging.wpsite.path,
|
|
#'url': reverse('WPHome', args=[staging.wpsite.owner.ProjectOwner.ProjectOwner.id, staging.wpsite.owner.ProjectOwner.id, staging.wpsite.id]),
|
|
'deleteURL': '%s?ID=%s&DeleteID=%s' % (reverse('WPHome'), staging.owner.id, staging.id)
|
|
}
|
|
if checker == 0:
|
|
json_data = json_data + json.dumps(dic)
|
|
checker = 1
|
|
else:
|
|
json_data = json_data + ',' + json.dumps(dic)
|
|
counter = counter + 1
|
|
|
|
json_data = json_data + ']'
|
|
return json_data
|
|
except BaseException as msg:
|
|
return msg
|
|
|
|
@staticmethod
|
|
def GetPHPVersionFromFile(vhFile, domainName=None):
|
|
|
|
if domainName == None:
|
|
# Your file path
|
|
file_path = vhFile
|
|
|
|
# Split the path by '/'
|
|
path_parts = file_path.split('/')
|
|
|
|
# Find the index of 'vhosts' in the path
|
|
vhosts_index = path_parts.index('vhosts')
|
|
|
|
# Extract the domain
|
|
domainName = path_parts[vhosts_index + 1]
|
|
|
|
finalConfPath = ApacheVhost.configBasePath + domainName + '.conf'
|
|
|
|
if os.path.exists('/usr/local/CyberCP/debug'):
|
|
logging.CyberCPLogFileWriter.writeToFile(f'Apache conf file in GetPHPVersionFromFile {finalConfPath}')
|
|
|
|
virtualHostName = domainName
|
|
if os.path.exists(finalConfPath):
|
|
|
|
|
|
######
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('54', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php54'
|
|
ubuntuPHP = 'php5.4'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('55', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php55'
|
|
ubuntuPHP = 'php5.5'
|
|
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('56', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php56'
|
|
ubuntuPHP = 'php5.6'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('70', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php70'
|
|
ubuntuPHP = 'php7.0'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('71', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php71'
|
|
ubuntuPHP = 'php7.1'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('72', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php72'
|
|
ubuntuPHP = 'php7.2'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('73', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php73'
|
|
ubuntuPHP = 'php7.3'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('74', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php74'
|
|
ubuntuPHP = 'php7.4'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('80', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php80'
|
|
ubuntuPHP = 'php8.0'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('81', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php81'
|
|
ubuntuPHP = 'php8.1'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('82', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php82'
|
|
ubuntuPHP = 'php8.2'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('83', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php83'
|
|
ubuntuPHP = 'php8.3'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('84', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php84'
|
|
ubuntuPHP = 'php8.4'
|
|
|
|
|
|
phpPath = ApacheVhost.DecidePHPPath('85', virtualHostName)
|
|
if os.path.exists(phpPath):
|
|
centOSPHP = 'php85'
|
|
ubuntuPHP = 'php8.5'
|
|
|
|
|
|
|
|
######
|
|
|
|
### not using below 2 lines in favor of code above
|
|
#command = f'grep -Eo -m 1 "php[0-9]+" {finalConfPath} | sed -n "1p"'
|
|
#php_version = ProcessUtilities.outputExecutioner(command, None, True).rstrip('\n')
|
|
|
|
# Input string
|
|
#php_version = "php73"
|
|
|
|
if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
|
|
command = f'/opt/remi/{centOSPHP}/root/bin/php'
|
|
return command
|
|
else:
|
|
# Insert a period between '7' and '3' to convert it to 'php7.3'
|
|
converted_version = ubuntuPHP
|
|
|
|
# Output the result
|
|
print(converted_version)
|
|
|
|
result = f'/usr/bin/{converted_version}'
|
|
#result = result.rsplit("lsphp", 1)[0] + "php"
|
|
return result
|
|
|
|
if os.path.exists('/usr/local/CyberCP/debug'):
|
|
logging.CyberCPLogFileWriter.writeToFile(f'VHFile in GetPHPVersion {vhFile}')
|
|
|
|
if ProcessUtilities.decideServer() == ProcessUtilities.OLS:
|
|
command = f'grep -Eo "/usr/local/lsws/lsphp[0-9]+/bin/lsphp" {vhFile}'
|
|
result = ProcessUtilities.outputExecutioner(command, None, True).rstrip('\n')
|
|
|
|
result = result.rsplit("lsphp", 1)[0] + "php"
|
|
return result
|
|
|
|
else:
|
|
command = f'grep -Po "php\\d+" {vhFile} | head -n 1'
|
|
result = ProcessUtilities.outputExecutioner(command, None, True).rstrip('\n')
|
|
result = f'/usr/local/lsws/ls{result}/bin/lsphp'
|
|
result = result.rsplit("lsphp", 1)[0] + "php"
|
|
return result
|
|
|
|
## returns something like PHP 8.2
|
|
@staticmethod
|
|
def WrapGetPHPVersionFromFileToGetVersionWithPHP(vhFile):
|
|
result = phpUtilities.GetPHPVersionFromFile(vhFile)
|
|
|
|
if os.path.exists(ProcessUtilities.debugPath):
|
|
logging.CyberCPLogFileWriter.writeToFile(result)
|
|
|
|
command = result + " -v 2>/dev/null | awk '/^PHP/ {print $2}'"
|
|
php_version = ProcessUtilities.outputExecutioner(command, None, True).rstrip('\n')[:3]
|
|
|
|
return f"PHP {php_version}"
|
|
|
|
@staticmethod
|
|
def FindIfSaidPHPIsAvaiableOtherwiseMaketheNextOneAvailableToUse(vhFile, phpVersion):
|
|
if vhFile != None:
|
|
virtualHostName = vhFile.split('/')[6]
|
|
result = phpUtilities.GetPHPVersionFromFile(vhFile, virtualHostName)
|
|
|
|
if os.path.exists(result):
|
|
return phpVersion
|
|
else:
|
|
from managePHP.phpManager import PHPManager
|
|
return PHPManager.findPHPVersions()[-2]
|
|
else:
|
|
from managePHP.phpManager import PHPManager
|
|
php = PHPManager.getPHPString(phpVersion)
|
|
finalPath = f'/usr/local/lsws/lsphp{php}/bin/php'
|
|
if os.path.exists(finalPath):
|
|
return phpVersion
|
|
else:
|
|
from managePHP.phpManager import PHPManager
|
|
return PHPManager.findPHPVersions()[-2]
|
|
|
|
|
|
@staticmethod
|
|
def InstallSaidPHP(php):
|
|
if ProcessUtilities.decideDistro() == ProcessUtilities.ubuntu or ProcessUtilities.decideDistro() == ProcessUtilities.ubuntu20:
|
|
command = f'DEBIAN_FRONTEND=noninteractive apt-get -y install lsphp{php}*'
|
|
else:
|
|
# Enhanced dependency handling for RHEL-based systems
|
|
# First try to install required dependencies
|
|
dependency_packages = [
|
|
'libmemcached', 'libmemcached-devel', 'libmemcached-libs',
|
|
'gd', 'gd-devel', 'libgd',
|
|
'c-client', 'c-client-devel',
|
|
'oniguruma', 'oniguruma-devel',
|
|
'libicu', 'libicu-devel',
|
|
'aspell', 'aspell-devel',
|
|
'pspell', 'pspell-devel'
|
|
]
|
|
|
|
# Install dependencies first
|
|
for dep in dependency_packages:
|
|
try:
|
|
dep_command = f'dnf install -y {dep} --skip-broken'
|
|
ProcessUtilities.executioner(dep_command, None, True)
|
|
except:
|
|
pass # Continue if dependency installation fails
|
|
|
|
# Install PHP with better error handling
|
|
command = f'dnf install lsphp{php}* --exclude *imagick* -y --skip-broken --nobest'
|
|
|
|
ProcessUtilities.executioner(command, None, True)
|
|
|
|
|
|
|
|
def main():
|
|
|
|
parser = argparse.ArgumentParser(description='CyberPanel Installer')
|
|
parser.add_argument('function', help='Specific a function to call!')
|
|
parser.add_argument('--phpVers', help='Domain name!')
|
|
parser.add_argument('--allow_url_fopen', help='Max Connections for PHP!')
|
|
parser.add_argument('--display_errors', help='Initial Request Timeout (secs) for PHP!')
|
|
parser.add_argument("--file_uploads", help="Persistent Connection for PHP!")
|
|
parser.add_argument("--allow_url_include", help="Memory Soft Limit (bytes) for PHP!")
|
|
parser.add_argument("--memory_limit", help="Process Hard Limit for PHP!")
|
|
parser.add_argument("--max_execution_time", help="Memory Hard Limit (bytes) for PHP!")
|
|
parser.add_argument("--upload_max_filesize", help="Process Soft Limit for PHP!")
|
|
parser.add_argument("--max_input_time", help="Process Hard Limit for PHP!")
|
|
parser.add_argument("--post_max_size", help="Process Hard Limit for PHP!")
|
|
parser.add_argument("--extension", help="Process Hard Limit for PHP!")
|
|
parser.add_argument("--apache", help="Editing apache!")
|
|
|
|
## Litespeed Tuning Arguments
|
|
|
|
parser.add_argument("--tempPath", help="Temporary path to file where PHP is storing data!")
|
|
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.function == "savePHPConfigBasic":
|
|
phpUtilities.savePHPConfigBasic(args.phpVers, args.allow_url_fopen, args.display_errors, args.file_uploads, args.allow_url_include, args.memory_limit,
|
|
args.max_execution_time, args.upload_max_filesize, args.max_input_time, args.post_max_size, args.apache)
|
|
elif args.function == "savePHPConfigAdvance":
|
|
phpUtilities.savePHPConfigAdvance(args.phpVers, args.tempPath)
|
|
|
|
elif args.function == "installPHPExtension":
|
|
phpUtilities.installPHPExtension(args.extension, args.extension)
|
|
|
|
elif args.function == "unInstallPHPExtension":
|
|
phpUtilities.unInstallPHPExtension(args.extension, args.extension)
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |