CyberPanel/install/installCyberPanel.py

import shutil
import subprocess
import os
from mysqlUtilities import mysqlUtilities
import installLog as logging
import randomPassword
import errno
import MySQLdb as mariadb
import install
from os.path import exists
import time
from installHelpers import PackageManager, ServiceManager, ConfigFileHandler, CommandExecutor, PHPInstaller, FileSystemHelper

# distros
centos = 0
ubuntu = 1
cent8 = 2
openeuler = 3


def get_Ubuntu_release():
    release = -1
    if exists("/etc/lsb-release"):
        distro_file = "/etc/lsb-release"
        with open(distro_file) as f:
            for line in f:
                if line[:16] == "DISTRIB_RELEASE=":
                    release = float(line[16:])

        if release == -1:
            print("Can't find distro release name in " + distro_file + " - fatal error")

    else:
        logging.InstallLog.writeToFile("Can't find linux release file - fatal error")
        print("Can't find linux release file - fatal error")
        os._exit(os.EX_UNAVAILABLE)

    return release


def FetchCloudLinuxAlmaVersionVersion():
    if os.path.exists('/etc/os-release'):
        data = open('/etc/os-release', 'r').read()
        if (data.find('CloudLinux') > -1 or data.find('cloudlinux') > -1) and (data.find('8.9') > -1 or data.find('Anatoly Levchenko') > -1 or data.find('VERSION="8.') > -1):
            return 'cl-89'
        elif (data.find('CloudLinux') > -1 or data.find('cloudlinux') > -1) and (data.find('8.8') > -1 or data.find('Anatoly Filipchenko') > -1):
            return 'cl-88'
        elif (data.find('CloudLinux') > -1 or data.find('cloudlinux') > -1) and (data.find('9.4') > -1 or data.find('VERSION="9.') > -1):
            return 'cl-88'
        elif (data.find('AlmaLinux') > -1 or data.find('almalinux') > -1) and (data.find('8.9') > -1 or data.find('Midnight Oncilla') > -1 or data.find('VERSION="8.') > -1):
            return 'al-88'
        elif (data.find('AlmaLinux') > -1 or data.find('almalinux') > -1) and (data.find('8.7') > -1 or data.find('Stone Smilodon') > -1):
            return 'al-87'
        elif (data.find('AlmaLinux') > -1 or data.find('almalinux') > -1) and (data.find('9.4') > -1 or data.find('9.3') > -1 or data.find('Shamrock Pampas') > -1 or data.find('Seafoam Ocelot') > -1 or data.find('VERSION="9.') > -1):
            return 'al-93'
    else:
        return -1

class InstallCyberPanel:
    mysql_Root_password = ""
    mysqlPassword = ""
    CloudLinux8 = 0

    @staticmethod
    def ISARM():

        try:
            command = 'uname -a'
            try:
                result = subprocess.run(command, capture_output=True, universal_newlines=True, shell=True)
            except:
                result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=True)

            if 'aarch64' in result.stdout:
                return True
            else:
                return False
        except:
            return False

    @staticmethod
    def OSFlags():
        if os.path.exists("/etc/redhat-release"):
            data = open('/etc/redhat-release', 'r').read()

            if data.find('CloudLinux 8') > -1 or data.find('cloudlinux 8') > -1:
                InstallCyberPanel.CloudLinux8 = 1

    def __init__(self, rootPath, cwd, distro, ent, serial=None, port=None, ftp=None, dns=None, publicip=None,
                 remotemysql=None, mysqlhost=None, mysqldb=None, mysqluser=None, mysqlpassword=None, mysqlport=None):
        self.server_root_path = rootPath
        self.cwd = cwd
        self.distro = distro
        self.ent = ent
        self.serial = serial
        self.port = port
        self.ftp = None
        self.dns = dns
        self.publicip = publicip
        self.remotemysql = remotemysql
        self.mysqlhost = mysqlhost
        self.mysqluser = mysqluser
        self.mysqlpassword = mysqlpassword
        self.mysqlport = mysqlport
        self.mysqldb = mysqldb

        ## TURN ON OS FLAGS FOR SPECIFIC NEEDS LATER

        InstallCyberPanel.OSFlags()

    @staticmethod
    def stdOut(message, log=0, exit=0, code=os.EX_OK):
        install.preFlightsChecks.stdOut(message, log, exit, code)

    def installLiteSpeed(self):
        if self.ent == 0:
            PackageManager.install_packages('openlitespeed', self.distro, ubuntu, centos, cent8, openeuler, 
                                          use_shell=(self.distro == ubuntu))

        else:
            try:
                try:
                    CommandExecutor.execute('groupadd nobody', self.distro, exit_on_error=False)
                except:
                    pass

                try:
                    CommandExecutor.execute('usermod -a -G nobody nobody', self.distro, exit_on_error=False)
                except:
                    pass

                if InstallCyberPanel.ISARM():
                    command = 'wget https://www.litespeedtech.com/packages/6.0/lsws-6.2-ent-aarch64-linux.tar.gz'
                else:
                    command = 'wget https://www.litespeedtech.com/packages/6.0/lsws-6.2-ent-x86_64-linux.tar.gz'

                CommandExecutor.execute(command, self.distro)

                if InstallCyberPanel.ISARM():
                    command = 'tar zxf lsws-6.2-ent-aarch64-linux.tar.gz'
                else:
                    command = 'tar zxf lsws-6.2-ent-x86_64-linux.tar.gz'

                CommandExecutor.execute(command, self.distro)

                if str.lower(self.serial) == 'trial':
                    command = 'wget -q --output-document=lsws-6.2/trial.key http://license.litespeedtech.com/reseller/trial.key'
                if self.serial == '1111-2222-3333-4444':
                    command = 'wget -q --output-document=/root/cyberpanel/install/lsws-6.2/trial.key http://license.litespeedtech.com/reseller/trial.key'
                    CommandExecutor.execute(command, self.distro)
                else:
                    writeSerial = open('lsws-6.2/serial.no', 'w')
                    writeSerial.writelines(self.serial)
                    writeSerial.close()

                shutil.copy('litespeed/install.sh', 'lsws-6.2/')
                shutil.copy('litespeed/functions.sh', 'lsws-6.2/')

                os.chdir('lsws-6.2')

                CommandExecutor.execute('chmod +x install.sh', self.distro)
                CommandExecutor.execute('chmod +x functions.sh', self.distro)
                CommandExecutor.execute('./install.sh', self.distro)

                os.chdir(self.cwd)
                confPath = '/usr/local/lsws/conf/'
                shutil.copy('litespeed/httpd_config.xml', confPath)
                shutil.copy('litespeed/modsec.conf', confPath)
                shutil.copy('litespeed/httpd.conf', confPath)

                CommandExecutor.execute('chown -R lsadm:lsadm ' + confPath, self.distro, exit_on_error=False)

            except BaseException as msg:
                logging.InstallLog.writeToFile('[ERROR] ' + str(msg) + " [installLiteSpeed]")
                return 0

            return 1

    def reStartLiteSpeed(self):
        command = self.server_root_path + "bin/lswsctrl restart"
        CommandExecutor.execute(command, self.distro, exit_on_error=False)

    def fix_ols_configs(self):
        try:
            InstallCyberPanel.stdOut("Fixing OpenLiteSpeed configurations!", 1)

            ## remove example virtual host
            config_path = self.server_root_path + "conf/httpd_config.conf"
            data = open(config_path, 'r').readlines()

            with open(config_path, 'w') as writeDataToFile:
                for items in data:
                    if not (items.find("map") > -1 and items.find("Example") > -1):
                        writeDataToFile.writelines(items)

            InstallCyberPanel.stdOut("OpenLiteSpeed Configurations fixed!", 1)
        except IOError as msg:
            logging.InstallLog.writeToFile('[ERROR] ' + str(msg) + " [fix_ols_configs]")
            return 0

        return self.reStartLiteSpeed()

    def changePortTo80(self):
        try:
            InstallCyberPanel.stdOut("Changing default port to 80..", 1)

            config_path = self.server_root_path + "conf/httpd_config.conf"
            replacements = [("*:8088", "*:80")]
            
            # Use sed for simple replacement
            ConfigFileHandler.sed_replace(config_path, "*:8088", "*:80", self.distro)

            InstallCyberPanel.stdOut("Default port is now 80 for OpenLiteSpeed!", 1)

        except IOError as msg:
            logging.InstallLog.writeToFile('[ERROR] ' + str(msg) + " [changePortTo80]")
            return 0

        return self.reStartLiteSpeed()

    def installAllPHPVersions(self):
        if self.distro == ubuntu:
            PHPInstaller.install_php_ubuntu()
        else:
            PHPInstaller.install_php_centos(self.distro, centos, cent8, openeuler)
        
        InstallCyberPanel.stdOut("LiteSpeed PHPs successfully installed!", 1)

    def installMySQL(self, mysql):

        ############## Install mariadb ######################

        if self.distro == ubuntu:
            PackageManager.install_packages('software-properties-common', self.distro, ubuntu, centos, cent8, openeuler, use_shell=True)
            PackageManager.install_packages('apt-transport-https curl', self.distro, ubuntu, centos, cent8, openeuler, use_shell=True)
            
            FileSystemHelper.create_directory('/etc/apt/keyrings')
            CommandExecutor.execute("curl -o /etc/apt/keyrings/mariadb-keyring.pgp 'https://mariadb.org/mariadb_release_signing_key.pgp'", self.distro)
            RepoPath = '/etc/apt/sources.list.d/mariadb.sources'
            # Determine the Ubuntu codename for MariaDB repo
            ubuntu_version = get_Ubuntu_release()
            if ubuntu_version >= 24.04:
                suite = 'noble'  # Ubuntu 24.04 LTS
            elif ubuntu_version >= 22.04:
                suite = 'jammy'  # Ubuntu 22.04 LTS
            else:
                suite = 'focal'  # Ubuntu 20.04 LTS and earlier
                
            RepoContent = f"""
# MariaDB 10.11 repository list - created 2023-12-11 07:53 UTC
# https://mariadb.org/download/
X-Repolib-Name: MariaDB
Types: deb
# deb.mariadb.org is a dynamic mirror if your preferred mirror goes offline. See https://mariadb.org/mirrorbits/ for details.
# URIs: https://deb.mariadb.org/10.11/ubuntu
URIs: https://mirrors.gigenet.com/mariadb/repo/10.11/ubuntu
Suites: {suite}
Components: main main/debug
Signed-By: /etc/apt/keyrings/mariadb-keyring.pgp
"""

            if get_Ubuntu_release() > 21.00:
                # Use the MariaDB repository setup script which automatically handles different Ubuntu versions
                command = 'curl -LsS https://downloads.mariadb.com/MariaDB/mariadb_repo_setup | sudo bash -s -- --mariadb-server-version=10.11'
                CommandExecutor.execute(command, self.distro, exit_code=os.EX_OSERR)
            #     WriteToFile = open(RepoPath, 'w')
            #     WriteToFile.write(RepoContent)
            #     WriteToFile.close()



            command = 'DEBIAN_FRONTEND=noninteractive apt-get update -y'
            install.preFlightsChecks.call(command, self.distro, command, command, 1, 1, os.EX_OSERR, True)


            command = "DEBIAN_FRONTEND=noninteractive apt-get install mariadb-server -y"
        elif self.distro == centos:

            RepoPath = '/etc/yum.repos.d/mariadb.repo'
            RepoContent = f"""
[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/10.11/rhel8-amd64
module_hotfixes=1
gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1            
"""
            WriteToFile = open(RepoPath, 'w')
            WriteToFile.write(RepoContent)
            WriteToFile.close()

            command = 'dnf install mariadb-server -y'
        elif self.distro == cent8 or self.distro == openeuler:

            clAPVersion = FetchCloudLinuxAlmaVersionVersion()
            type = clAPVersion.split('-')[0]
            version = int(clAPVersion.split('-')[1])


            if type == 'cl' and version >= 88:
                CommandExecutor.execute('yum remove db-governor db-governor-mysql -y', self.distro)
                PackageManager.install_packages('governor-mysql', self.distro, ubuntu, centos, cent8, openeuler)
                CommandExecutor.execute('/usr/share/lve/dbgovernor/mysqlgovernor.py --mysql-version=mariadb106', self.distro)
                command = '/usr/share/lve/dbgovernor/mysqlgovernor.py --install --yes'

            else:
                CommandExecutor.execute('curl -LsS https://downloads.mariadb.com/MariaDB/mariadb_repo_setup | sudo bash -s -- --mariadb-server-version=10.11', self.distro)
                CommandExecutor.execute('yum remove mariadb* -y', self.distro)
                CommandExecutor.execute('sudo dnf -qy module disable mariadb', self.distro)
                CommandExecutor.execute('sudo dnf module reset mariadb -y', self.distro)


                command = 'dnf install MariaDB-server MariaDB-client MariaDB-backup -y'

        install.preFlightsChecks.call(command, self.distro, command, command, 1, 1, os.EX_OSERR, True)

        ############## Start mariadb ######################

        self.startMariaDB()

    def changeMYSQLRootPassword(self):
        if self.remotemysql == 'OFF':
            if self.distro == ubuntu:
                passwordCMD = "use mysql;DROP DATABASE IF EXISTS test;DELETE FROM mysql.db WHERE Db='test' OR Db='test\\_%%';GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY '%s';UPDATE user SET plugin='' WHERE User='root';flush privileges;" % (
                    InstallCyberPanel.mysql_Root_password)
            else:
                passwordCMD = "use mysql;DROP DATABASE IF EXISTS test;DELETE FROM mysql.db WHERE Db='test' OR Db='test\\_%%';GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY '%s';flush privileges;" % (
                    InstallCyberPanel.mysql_Root_password)

            command = 'mariadb -u root -e "' + passwordCMD + '"'

            install.preFlightsChecks.call(command, self.distro, command, command, 0, 0, os.EX_OSERR)

    def startMariaDB(self):
        if self.remotemysql == 'OFF':
            ############## Start mariadb ######################
            ServiceManager.start_service('mariadb', self.distro)

            ############## Enable mariadb at system startup ######################
            if os.path.exists('/etc/systemd/system/mysqld.service'):
                os.remove('/etc/systemd/system/mysqld.service')
            if os.path.exists('/etc/systemd/system/mariadb.service'):
                os.remove('/etc/systemd/system/mariadb.service')

            ServiceManager.enable_service('mariadb', self.distro)

    def fixMariaDB(self):
        self.stdOut("Setup MariaDB so it can support Cyberpanel's needs")

        conn = mariadb.connect(user='root', passwd=self.mysql_Root_password)
        cursor = conn.cursor()
        cursor.execute('set global innodb_file_per_table = on;')
        try:
            cursor.execute('set global innodb_file_format = Barracuda;')
            cursor.execute('set global innodb_large_prefix = on;')
        except BaseException as msg:
            self.stdOut('%s. [ERROR:335]' % (str(msg)))
        cursor.close()
        conn.close()

        try:
            fileName = '/etc/mysql/mariadb.conf.d/50-server.cnf'
            ConfigFileHandler.sed_replace(fileName, 'utf8mb4', 'utf8', self.distro)
        except IOError as err:
            self.stdOut("[ERROR] Error in setting: " + fileName + ": " + str(err), 1, 1, os.EX_OSERR)

        ServiceManager.restart_service('mariadb', self.distro)

        self.stdOut("MariaDB is now setup so it can support Cyberpanel's needs")

    def installPureFTPD(self):
        if self.distro == ubuntu:
            command = 'DEBIAN_FRONTEND=noninteractive apt install pure-ftpd-mysql -y'
            os.system(command)

            if get_Ubuntu_release() == 18.10:
                urls = [
                    'https://rep.cyberpanel.net/pure-ftpd-common_1.0.47-3_all.deb',
                    'https://rep.cyberpanel.net/pure-ftpd-mysql_1.0.47-3_amd64.deb'
                ]
                packages = [
                    'pure-ftpd-common_1.0.47-3_all.deb',
                    'pure-ftpd-mysql_1.0.47-3_amd64.deb'
                ]
                
                for url in urls:
                    CommandExecutor.execute(f'wget {url}', self.distro)
                
                for package in packages:
                    CommandExecutor.execute(f'dpkg --install --force-confold {package}', self.distro)
        else:
            PackageManager.install_packages('pure-ftpd', self.distro, ubuntu, centos, cent8, openeuler)

        ####### Install pureftpd to system startup
        service_name = install.preFlightsChecks.pureFTPDServiceName(self.distro)
        ServiceManager.enable_service(service_name, self.distro)

        ###### FTP Groups and user settings settings
        FileSystemHelper.create_user_and_group('ftpuser', 'ftpgroup', 2001, 2001, 
                                             shell='/bin/false', home='/bin/null', distro=self.distro)

    def startPureFTPD(self):
        ############## Start pureftpd ######################
        service_name = 'pure-ftpd-mysql' if self.distro == ubuntu else 'pure-ftpd'
        ServiceManager.start_service(service_name, self.distro)

    def installPureFTPDConfigurations(self, mysql):
        try:
            ## setup ssl for ftp

            InstallCyberPanel.stdOut("Configuring PureFTPD..", 1)

            FileSystemHelper.create_directory("/etc/ssl/private")

            if (self.distro == centos or self.distro == cent8 or self.distro == openeuler) or (
                    self.distro == ubuntu and get_Ubuntu_release() == 18.14):
                command = 'openssl req -newkey rsa:1024 -new -nodes -x509 -days 3650 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout /etc/ssl/private/pure-ftpd.pem -out /etc/ssl/private/pure-ftpd.pem'
            else:
                command = 'openssl req -x509 -nodes -days 7300 -newkey rsa:2048 -subj "/C=US/ST=Denial/L=Sprinal-ield/O=Dis/CN=www.example.com" -keyout /etc/ssl/private/pure-ftpd.pem -out /etc/ssl/private/pure-ftpd.pem'

            CommandExecutor.execute(command, self.distro, exit_on_error=False)

            os.chdir(self.cwd)
            ftpdPath = "/etc/pure-ftpd"

            if os.path.exists(ftpdPath):
                shutil.rmtree(ftpdPath)
                if mysql == 'Two':
                    shutil.copytree("pure-ftpd", ftpdPath)
                else:
                    shutil.copytree("pure-ftpd-one", ftpdPath)
            else:
                if mysql == 'Two':
                    shutil.copytree("pure-ftpd", ftpdPath)
                else:
                    shutil.copytree("pure-ftpd-one", ftpdPath)

            if self.distro == ubuntu:
                for dir_path in ['/etc/pure-ftpd/conf', '/etc/pure-ftpd/auth', '/etc/pure-ftpd/db']:
                    FileSystemHelper.create_directory(dir_path)

            # Update MySQL password in pureftpd config
            pureftpd_config = ftpdPath + "/pureftpd-mysql.conf"
            replacements = [("MYSQLPassword", "MYSQLPassword " + InstallCyberPanel.mysqlPassword)]
            ConfigFileHandler.replace_in_file(pureftpd_config, replacements)

            ftpConfPath = '/etc/pure-ftpd/pureftpd-mysql.conf'

            if self.remotemysql == 'ON':
                ConfigFileHandler.sed_replace(ftpConfPath, 'localhost', self.mysqlhost, self.distro)
                ConfigFileHandler.sed_replace(ftpConfPath, '3306', self.mysqlport, self.distro)
                ConfigFileHandler.sed_replace(ftpConfPath, 'MYSQLSocket /var/lib/mysql/mysql.sock', '', self.distro)

            if self.distro == ubuntu:

                if os.path.exists('/etc/pure-ftpd/db/mysql.conf'):
                    os.remove('/etc/pure-ftpd/db/mysql.conf')
                    shutil.copy(ftpdPath + "/pureftpd-mysql.conf", '/etc/pure-ftpd/db/mysql.conf')
                else:
                    shutil.copy(ftpdPath + "/pureftpd-mysql.conf", '/etc/pure-ftpd/db/mysql.conf')

                # Write configuration values to files
                config_values = [
                    ('1', '/etc/pure-ftpd/conf/TLS'),
                    (str(self.publicip), '/etc/pure-ftpd/conf/ForcePassiveIP'),
                    ('40110 40210', '/etc/pure-ftpd/conf/PassivePortRange'),
                    ('no', '/etc/pure-ftpd/conf/UnixAuthentication'),
                    ('/etc/pure-ftpd/db/mysql.conf', '/etc/pure-ftpd/conf/MySQLConfigFile')
                ]
                
                for value, filepath in config_values:
                    with open(filepath, 'w') as f:
                        f.write(value)

                CommandExecutor.execute('ln -s /etc/pure-ftpd/conf/MySQLConfigFile /etc/pure-ftpd/auth/30mysql', self.distro)
                CommandExecutor.execute('ln -s /etc/pure-ftpd/conf/UnixAuthentication /etc/pure-ftpd/auth/65unix', self.distro)
                ServiceManager.restart_service('pure-ftpd-mysql.service', self.distro)




                ubuntu_version = get_Ubuntu_release()
                if ubuntu_version > 21.00:
                    ### change mysql md5 to crypt for Ubuntu 22.04+ including 24.04
                    ConfigFileHandler.sed_replace('/etc/pure-ftpd/db/mysql.conf', 'MYSQLCrypt md5', 'MYSQLCrypt crypt', self.distro)
                    ServiceManager.restart_service('pure-ftpd-mysql.service', self.distro)
            else:

                try:
                    clAPVersion = FetchCloudLinuxAlmaVersionVersion()
                    type = clAPVersion.split('-')[0]
                    version = int(clAPVersion.split('-')[1])

                    if type == 'al' and version >= 90:
                        ConfigFileHandler.sed_replace('/etc/pure-ftpd/pureftpd-mysql.conf', 'MYSQLCrypt md5', 'MYSQLCrypt crypt', self.distro)
                except:
                    pass



            InstallCyberPanel.stdOut("PureFTPD configured!", 1)

        except IOError as msg:
            logging.InstallLog.writeToFile('[ERROR] ' + str(msg) + " [installPureFTPDConfigurations]")
            return 0

    def installPowerDNS(self):
        try:
            if self.distro == ubuntu or self.distro == cent8 or self.distro == openeuler:
                ServiceManager.stop_service('systemd-resolved', self.distro, exit_on_error=False)
                ServiceManager.disable_service('systemd-resolved.service', self.distro, exit_on_error=False)

                try:
                    os.rename('/etc/resolv.conf', 'etc/resolved.conf')
                except OSError as e:
                    if e.errno != errno.EEXIST and e.errno != errno.ENOENT:
                        InstallCyberPanel.stdOut("[ERROR] Unable to rename /etc/resolv.conf to install PowerDNS: " +
                                                 str(e), 1, 1, os.EX_OSERR)
                    try:
                        os.remove('/etc/resolv.conf')
                    except OSError as e1:
                        InstallCyberPanel.stdOut(
                            "[ERROR] Unable to remove existing /etc/resolv.conf to install PowerDNS: " +
                            str(e1), 1, 1, os.EX_OSERR)

                # try:
                #     f = open('/etc/resolv.conf', 'a')
                #     f.write('nameserver 8.8.8.8')
                #     f.close()
                # except IOError as e:
                #     InstallCyberPanel.stdOut("[ERROR] Unable to create /etc/resolv.conf: " + str(e) +
                #                              ".  This may need to be fixed manually as 'echo \"nameserver 8.8.8.8\"> "
                #                              "/etc/resolv.conf'", 1, 1, os.EX_OSERR)

            if self.distro == ubuntu:
                command = "DEBIAN_FRONTEND=noninteractive apt-get -y install pdns-server pdns-backend-mysql"
                os.system(command)
                return 1
            else:
                PackageManager.install_packages('pdns pdns-backend-mysql', self.distro, ubuntu, centos, cent8, openeuler)

        except BaseException as msg:
            logging.InstallLog.writeToFile('[ERROR] ' + str(msg) + " [powerDNS]")

    def installPowerDNSConfigurations(self, mysqlPassword, mysql):
        try:

            InstallCyberPanel.stdOut("Configuring PowerDNS..", 1)

            os.chdir(self.cwd)
            if self.distro == centos or self.distro == cent8 or self.distro == openeuler:
                dnsPath = "/etc/pdns/pdns.conf"
            else:
                dnsPath = "/etc/powerdns/pdns.conf"

            if os.path.exists(dnsPath):
                os.remove(dnsPath)
                if mysql == 'Two':
                    shutil.copy("dns/pdns.conf", dnsPath)
                else:
                    shutil.copy("dns-one/pdns.conf", dnsPath)
            else:
                if mysql == 'Two':
                    shutil.copy("dns/pdns.conf", dnsPath)
                else:
                    shutil.copy("dns-one/pdns.conf", dnsPath)

            # Update MySQL password in PowerDNS config
            replacements = [("gmysql-password", "gmysql-password=" + mysqlPassword)]
            ConfigFileHandler.replace_in_file(dnsPath, replacements)

            if self.remotemysql == 'ON':
                ConfigFileHandler.sed_replace(dnsPath, 'gmysql-host=localhost', f'gmysql-host={self.mysqlhost}', self.distro)
                ConfigFileHandler.sed_replace(dnsPath, 'gmysql-port=3306', f'gmysql-port={self.mysqlport}', self.distro)

            InstallCyberPanel.stdOut("PowerDNS configured!", 1)

        except IOError as msg:
            logging.InstallLog.writeToFile('[ERROR] ' + str(msg) + " [installPowerDNSConfigurations]")
            return 0
        return 1

    def startPowerDNS(self):
        ############## Start PowerDNS ######################
        ServiceManager.enable_service('pdns', self.distro)
        ServiceManager.start_service('pdns', self.distro)


def Main(cwd, mysql, distro, ent, serial=None, port="8090", ftp=None, dns=None, publicip=None, remotemysql=None,
         mysqlhost=None, mysqldb=None, mysqluser=None, mysqlpassword=None, mysqlport=None):
    InstallCyberPanel.mysqlPassword = randomPassword.generate_pass()
    InstallCyberPanel.mysql_Root_password = randomPassword.generate_pass()

    file_name = '/etc/cyberpanel/mysqlPassword'

    if remotemysql == 'OFF':
        if os.access(file_name, os.F_OK):
            password = open(file_name, 'r')
            InstallCyberPanel.mysql_Root_password = password.readline()
            password.close()
        else:
            password = open(file_name, "w")
            password.writelines(InstallCyberPanel.mysql_Root_password)
            password.close()
    else:
        mysqlData = {'remotemysql': remotemysql, 'mysqlhost': mysqlhost, 'mysqldb': mysqldb, 'mysqluser': mysqluser,
                     'mysqlpassword': mysqlpassword, 'mysqlport': mysqlport}
        from json import dumps
        writeToFile = open(file_name, 'w')
        writeToFile.write(dumps(mysqlData))
        writeToFile.close()

        if install.preFlightsChecks.debug:
            print(open(file_name, 'r').read())
            time.sleep(10)

    try:
        CommandExecutor.execute(f'chmod 640 {file_name}', distro, '[chmod]', exit_on_error=False)
        CommandExecutor.execute(f'chown root:cyberpanel {file_name}', distro, '[chmod]', exit_on_error=False)
    except:
        pass

    if distro == centos:
        InstallCyberPanel.mysqlPassword = randomPassword.generate_pass()
    else:
        InstallCyberPanel.mysqlPassword = InstallCyberPanel.mysql_Root_password

    installer = InstallCyberPanel("/usr/local/lsws/", cwd, distro, ent, serial, port, ftp, dns, publicip, remotemysql,
                                  mysqlhost, mysqldb, mysqluser, mysqlpassword, mysqlport)

    logging.InstallLog.writeToFile('Installing LiteSpeed Web server,40')
    installer.installLiteSpeed()
    if ent == 0:
        installer.changePortTo80()
    logging.InstallLog.writeToFile('Installing Optimized PHPs..,50')
    installer.installAllPHPVersions()
    if ent == 0:
        installer.fix_ols_configs()

    logging.InstallLog.writeToFile('Installing MySQL,60')
    installer.installMySQL(mysql)
    installer.changeMYSQLRootPassword()

    installer.startMariaDB()

    if remotemysql == 'OFF':
        if distro == ubuntu:
            installer.fixMariaDB()

    mysqlUtilities.createDatabase("cyberpanel", "cyberpanel", InstallCyberPanel.mysqlPassword, publicip)

    if ftp is None:
        installer.installPureFTPD()
        installer.installPureFTPDConfigurations(mysql)
        installer.startPureFTPD()
    else:
        if ftp == 'ON':
            installer.installPureFTPD()
            installer.installPureFTPDConfigurations(mysql)
            installer.startPureFTPD()

    if dns is None:
        installer.installPowerDNS()
        installer.installPowerDNSConfigurations(InstallCyberPanel.mysqlPassword, mysql)
        installer.startPowerDNS()
    else:
        if dns == 'ON':
            installer.installPowerDNS()
            installer.installPowerDNSConfigurations(InstallCyberPanel.mysqlPassword, mysql)
            installer.startPowerDNS()