bug fix to backups and manage services

backup/urls.py

@@ -46,6 +46,8 @@ urlpatterns = [
 
     url(r'^cancelRemoteBackup', views.cancelRemoteBackup, name='cancelRemoteBackup'),
 
+    url(r'^localInitiate$', views.localInitiate, name='localInitiate'),
+
 
 
 

backup/views.py

@@ -9,7 +9,10 @@ from django.shortcuts import redirect
 from backup.backupManager import BackupManager
 from backup.pluginManager import pluginManager
 from loginSystem.views import loadLoginPage
-
+import os
+from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
+from django.shortcuts import HttpResponse
+from django.views.decorators.csrf import csrf_exempt
 
 def loadBackupHome(request):
     try:
@@ -45,7 +48,6 @@ def getCurrentBackups(request):
     except KeyError:
         return redirect(loadLoginPage)
 
-
 def submitBackupCreation(request):
     try:
         userID = request.session['userID']
@@ -59,8 +61,8 @@ def submitBackupCreation(request):
 
         return coreResult
 
-    except KeyError:
+    except BaseException, msg:
-        return redirect(loadLoginPage)
+        logging.writeToFile(str(msg))
 
 
 def backupStatus(request):
@@ -324,3 +326,16 @@ def cancelRemoteBackup(request):
         return wm.cancelRemoteBackup(userID, json.loads(request.body))
     except KeyError:
         return redirect(loadLoginPage)
+
+
+@csrf_exempt
+def localInitiate(request):
+    try:
+        data = json.loads(request.body)
+        randomFile = data['randomFile']
+
+        if os.path.exists(randomFile):
+            wm = BackupManager()
+            return wm.submitBackupCreation(1, json.loads(request.body))
+    except BaseException, msg:
+        logging.writeToFile(str(msg))

cli/cyberPanel.py

@@ -23,6 +23,7 @@ from plogical.mailUtilities import mailUtilities
 from plogical.ftpUtilities import FTPUtilities
 from plogical.sslUtilities import sslUtilities
 from plogical.processUtilities import ProcessUtilities
+from plogical.backupSchedule import backupSchedule
 
 # All that we see or seem is but a dream within a dream.
 
@@ -323,37 +324,11 @@ class cyberPanel:
 
     def createBackup(self, virtualHostName):
         try:
-            website = Websites.objects.get(domain=virtualHostName)
+            backupLogPath = "/usr/local/lscp/logs/backup_log."+time.strftime("%I-%M-%S-%a-%b-%Y")
 
-            ## defining paths
+            print 'Backup logs to be generated in %s' % (backupLogPath)
-
-            ## /home/example.com/backup
-            backupPath = os.path.join("/home", virtualHostName, "backup/")
-            domainUser = website.externalApp
-            backupName = 'backup-' + domainUser + "-" + time.strftime("%I-%M-%S-%a-%b-%Y")
-
-            ## /home/example.com/backup/backup-example-06-50-03-Thu-Feb-2018
-            tempStoragePath = os.path.join(backupPath, backupName)
-
-            backupUtilities.submitBackupCreation(tempStoragePath, backupName, backupPath, virtualHostName)
-
-            finalData = json.dumps({'websiteToBeBacked': virtualHostName})
-
-            while (1):
-                r = requests.post("http://localhost:5003/backup/backupStatus", data=finalData)
-                time.sleep(2)
-                data = json.loads(r.text)
-
-                if data['backupStatus'] == 0:
-                    print 'Failed to generate backup, Error message : ' + data['error_message'] + '\n'
-                    break
-                elif data['abort'] == 1:
-                    print 'Backup successfully generated.\n'
-                    print 'File Location: ' + tempStoragePath + ".tar.gz\n"
-                    break
-                else:
-                    print 'Waiting for backup to complete. Current status: ' + data['status']
 
+            backupSchedule.createLocalBackup(virtualHostName, backupLogPath)
 
         except BaseException, msg:
             logger.writeforCLI(str(msg), "Error", stack()[0][3])

manageServices/views.py

@@ -191,6 +191,8 @@ def saveStatus(request):
                                 slaveServer.save()
                             except:
                                 pass
+                        else:
+                            pdns.save()
 
                         if data['dnsMode'] != 'Default':
                             data['type'] = data['dnsMode']

plogical/backupSchedule.py

@@ -13,10 +13,11 @@ import time
 from backupUtilities import backupUtilities
 from re import match,I,M
 from websiteFunctions.models import Websites, Backups
-from plogical.virtualHostUtilities import virtualHostUtilities
 from plogical.processUtilities import ProcessUtilities
 from multiprocessing import Process
 import plogical.backupUtilities as backupUtil
+from random import randint
+import json, requests
 
 class backupSchedule:
 
@@ -25,6 +26,7 @@ class backupSchedule:
         try:
             file = open(fileName,'a')
             file.writelines("[" + time.strftime("%I-%M-%S-%a-%b-%Y") + "] "+ message + "\n")
+            print ("[" + time.strftime("%I-%M-%S-%a-%b-%Y") + "] "+ message + "\n")
             file.close()
         except IOError,msg:
             return "Can not write to error file."
@@ -34,28 +36,22 @@ class backupSchedule:
         try:
 
             backupSchedule.remoteBackupLogging(backupLogPath, "Starting local backup for: " + virtualHost)
-            website = Websites.objects.get(domain=virtualHost)
-            # defining paths
 
-            ## /home/example.com/backup
+            ###
-            backupPath = os.path.join("/home", virtualHost, "backup/")
-            domainUser = website.externalApp
-            backupName = 'backup-' + domainUser + "-" + time.strftime("%I-%M-%S-%a-%b-%Y")
 
-            ## /home/example.com/backup/backup-example-06-50-03-Thu-Feb-2018
+            pathToFile = "/home/cyberpanel/" + str(randint(1000, 9999))
-            tempStoragePath = os.path.join(backupPath, backupName)
+            file = open(pathToFile, "w+")
+            file.close()
 
-            p = Process(target=backupUtil.submitBackupCreation,
+            finalData = json.dumps({'randomFile': pathToFile, 'websiteToBeBacked': virtualHost})
-                        args=(tempStoragePath, backupName, backupPath, virtualHost))
+            r = requests.post("https://localhost:8090/backup/localInitiate", data=finalData, verify=False)
-            p.start()
 
-            time.sleep(2)
+            data = json.loads(r.text)
+            tempStoragePath = data['tempStorage']
 
             backupSchedule.remoteBackupLogging(backupLogPath, "Waiting for backup to complete.. ")
 
-
             while (1):
-
                 backupDomain = virtualHost
                 status = os.path.join("/home", backupDomain, "backup/status")
                 backupFileNamePath = os.path.join("/home", backupDomain, "backup/backupFileName")
@@ -71,6 +67,8 @@ class backupSchedule:
 
                 if os.path.exists(status):
                     status = open(status, 'r').read()
+                    print status
+                    time.sleep(2)
 
                     if status.find("Completed") > -1:
 
@@ -86,9 +84,12 @@ class backupSchedule:
                         ProcessUtilities.normalExecutioner(command)
 
                         backupSchedule.remoteBackupLogging(backupLogPath, "Backup Completed for: " + virtualHost)
+                        try:
+                            os.remove(pathToFile)
+                        except:
+                            pass
                         return 1, tempStoragePath
 
-
                     elif status.find("[5009]") > -1:
                         ## removing status file, so that backup can re-run
                         try:
@@ -109,9 +110,13 @@ class backupSchedule:
                             pass
 
                         backupSchedule.remoteBackupLogging(backupLogPath, "An error occurred, Error message: " + status)
+                        try:
+                            os.remove(pathToFile)
+                        except:
+                            pass
                         return 0, tempStoragePath
         except BaseException, msg:
-            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [119:startBackup]")
             return 0, "None"
 
     @staticmethod
@@ -181,7 +186,7 @@ class backupSchedule:
             os.remove(backupPath)
 
         except BaseException, msg:
-            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [189:startBackup]")
 
     @staticmethod
     def prepare():

plogical/backupScheduleLocal.py

@@ -35,7 +35,7 @@ class backupScheduleLocal:
             writeToFile.close()
 
         except BaseException,msg:
-            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [214:startBackup]")
 
 def main():
     backupScheduleLocal.prepare()

plogical/backupUtilities.py

@@ -17,26 +17,34 @@ from multiprocessing import Process
 import signal
 from installUtilities import installUtilities
 import argparse
-from virtualHostUtilities import virtualHostUtilities
+try:
-from sslUtilities import sslUtilities
+    from virtualHostUtilities import virtualHostUtilities
-from websiteFunctions.models import Websites, ChildDomains, Backups
+    from sslUtilities import sslUtilities
-from databases.models import Databases
+    from plogical.mailUtilities import mailUtilities
-from loginSystem.models import Administrator
+except:
-from dnsUtilities import DNS
+    pass
+
 from xml.etree.ElementTree import Element, SubElement
 from xml.etree import ElementTree
 from xml.dom import minidom
-from backup.models import DBUsers
-from mailServer.models import Domains as eDomains
 import time
-from plogical.mailUtilities import mailUtilities
 from shutil import copy
 from random import randint
 from plogical.processUtilities import ProcessUtilities
+try:
+    from websiteFunctions.models import Websites, ChildDomains, Backups
+    from databases.models import Databases
+    from loginSystem.models import Administrator
+    from dnsUtilities import DNS
+    from mailServer.models import Domains as eDomains
+    from backup.models import DBUsers
+except:
+    pass
 
 ## I am not the monster that you think I am..
 
 class backupUtilities:
+    Server_root = "/usr/local/lsws"
 
     completeKeyPath  = "/home/cyberpanel/.ssh"
     destinationsPath = "/home/cyberpanel/destinations"
@@ -46,6 +54,10 @@ class backupUtilities:
     def prepareBackupMeta(backupDomain, backupName, tempStoragePath, backupPath):
         try:
 
+            status = os.path.join(backupPath, 'status')
+
+            logging.CyberCPLogFileWriter.statusWriter(status, 'Setting up meta data..')
+
             website = Websites.objects.get(domain=backupDomain)
 
             ######### Generating meta
@@ -194,10 +206,13 @@ class backupUtilities:
                                 size=0, status=1)
             newBackup.save()
 
+            logging.CyberCPLogFileWriter.statusWriter(status, 'Meta data us ready..')
+
             return 1,'None', metaPath
 
 
         except BaseException, msg:
+            logging.CyberCPLogFileWriter.statusWriter(status, "%s [207][5009]" % (str(msg)))
             return 0,str(msg)
 
     @staticmethod
@@ -207,12 +222,6 @@ class backupUtilities:
             ## /home/example.com/backup/backup-example-06-50-03-Thu-Feb-2018 -- tempStoragePath
             ## /home/example.com/backup - backupPath
 
-            if not os.path.exists(backupPath):
-                os.mkdir(backupPath)
-
-            if not os.path.exists(tempStoragePath):
-                os.mkdir(tempStoragePath)
-
             ##### Writing the name of backup file.
 
             ## /home/example.com/backup/backupFileName
@@ -246,7 +255,7 @@ class backupUtilities:
 
             ## Saving original vhost conf file
 
-            completPathToConf = virtualHostUtilities.Server_root + '/conf/vhosts/' + domainName + '/vhost.conf'
+            completPathToConf = backupUtilities.Server_root + '/conf/vhosts/' + domainName + '/vhost.conf'
 
             if os.path.exists(backupUtilities.licenseKey):
                 copy(completPathToConf, tempStoragePath + '/vhost.conf')
@@ -279,7 +288,7 @@ class backupUtilities:
                     actualChildDomain = childDomain.find('domain').text
 
                     if os.path.exists(backupUtilities.licenseKey):
-                        completPathToConf = virtualHostUtilities.Server_root + '/conf/vhosts/' + actualChildDomain + '/vhost.conf'
+                        completPathToConf = backupUtilities.Server_root + '/conf/vhosts/' + actualChildDomain + '/vhost.conf'
                         copy(completPathToConf, tempStoragePath + '/' + actualChildDomain + '.vhost.conf')
 
                         ### Storing SSL for child domainsa
@@ -299,25 +308,25 @@ class backupUtilities:
                         except:
                             pass
             except BaseException, msg:
-                logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+                pass
 
-            logging.CyberCPLogFileWriter.statusWriter(status, "Backing up databases.")
+            logging.CyberCPLogFileWriter.statusWriter(status, "Backing up databases..")
             print '1,None'
 
         except BaseException,msg:
             try:
                 os.remove(os.path.join(backupPath,backupName+".tar.gz"))
             except:
-                logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+                pass
 
             try:
                 rmtree(tempStoragePath)
             except:
-                logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+                pass
 
             status = os.path.join(backupPath, 'status')
             logging.CyberCPLogFileWriter.statusWriter(status, "Aborted, "+ str(msg) + ".[365] [5009]")
-            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+            print ("Aborted, "+ str(msg) + ".[365] [5009]")
 
     @staticmethod
     def BackupRoot(tempStoragePath, backupName, backupPath, metaPath=None):
@@ -331,16 +340,16 @@ class backupUtilities:
 
         if os.path.islink(status) or os.path.islink(tempStoragePath or os.path.islink(backupPath)) or os.path.islink(metaPath):
             logging.CyberCPLogFileWriter.writeToFile('symlinked.')
+            logging.CyberCPLogFileWriter.statusWriter(status, 'Symlink attack. [5009]')
             return 0
 
         ## backup email accounts
 
-        logging.CyberCPLogFileWriter.statusWriter(status, "Backing up email accounts!\n")
+        logging.CyberCPLogFileWriter.statusWriter(status, "Backing up email accounts..\n")
 
         try:
             make_archive(os.path.join(tempStoragePath, domainName), 'gztar', os.path.join("/home", "vmail", domainName))
         except BaseException, msg:
-            print str(msg)
             pass
 
 
@@ -576,7 +585,7 @@ class backupUtilities:
 
                             if os.path.exists(backupUtilities.licenseKey):
                                 if os.path.exists(completPath + '/' + domain + '.vhost.conf'):
-                                    completPathToConf = virtualHostUtilities.Server_root + '/conf/vhosts/' + domain + '/vhost.conf'
+                                    completPathToConf = backupUtilities.Server_root + '/conf/vhosts/' + domain + '/vhost.conf'
                                     copy(completPath + '/' + domain + '.vhost.conf', completPathToConf)
 
                             sslStoragePath = completPath + "/" + domain + ".cert.pem"
@@ -688,7 +697,7 @@ class backupUtilities:
             ## emails extracted
 
             if os.path.exists(backupUtilities.licenseKey):
-                completPathToConf = virtualHostUtilities.Server_root + '/conf/vhosts/' + masterDomain + '/vhost.conf'
+                completPathToConf = backupUtilities.Server_root + '/conf/vhosts/' + masterDomain + '/vhost.conf'
                 if os.path.exists(completPath + '/vhost.conf'):
                     copy(completPath + '/vhost.conf', completPathToConf)
 
@@ -996,20 +1005,48 @@ def submitBackupCreation(tempStoragePath, backupName, backupPath, backupDomain):
         ## /home/cyberpanel/1047.xml - metaPath
 
         status = os.path.join(backupPath, 'status')
+        website = Websites.objects.get(domain=backupDomain)
+
+        ##
+
+        command = 'mkdir -p %s' % (backupPath)
+        ProcessUtilities.executioner(command)
+
+        command = 'chown -R %s:%s %s' % (website.externalApp, website.externalApp, backupPath)
+        ProcessUtilities.executioner(command)
+
+        ##
+
+
+        command = 'mkdir -p %s' % (tempStoragePath)
+        ProcessUtilities.executioner(command)
+
+        command = 'chown -R %s:%s %s' % (website.externalApp, website.externalApp, tempStoragePath)
+        ProcessUtilities.executioner(command)
+
+        ##
+
+        command = 'chown cyberpanel:cyberpanel %s' % (status)
+        ProcessUtilities.executioner(command)
+
         result = backupUtilities.prepareBackupMeta(backupDomain, backupName, tempStoragePath, backupPath)
 
-        if result[0] == 0:
-            logging.CyberCPLogFileWriter.writeToFile(result[1] + ' [5009]')
-            logging.CyberCPLogFileWriter.statusWriter(status, result[1] + ' [5009]')
-            return
 
-        website = Websites.objects.get(domain=backupDomain)
+        if result[0] == 0:
+            logging.CyberCPLogFileWriter.statusWriter(status, str(result[1]) + ' [5009]')
+            return 0
+
+        command = 'chown %s:%s %s' % (website.externalApp, website.externalApp, status)
+        ProcessUtilities.executioner(command)
 
         execPath = "sudo nice -n 10 python " + virtualHostUtilities.cyberPanel + "/plogical/backupUtilities.py"
         execPath = execPath + " startBackup --tempStoragePath " + tempStoragePath + " --backupName " \
                    + backupName + " --backupPath " + backupPath + ' --backupDomain ' + backupDomain + ' --metaPath %s' % (result[2])
 
-        ProcessUtilities.executioner(execPath, website.externalApp)
+        output = ProcessUtilities.outputExecutioner(execPath, website.externalApp)
+        if output.find('[5009') > -1:
+            logging.CyberCPLogFileWriter.writeToFile(output)
+            return 0
 
         ## Backing up databases
 
@@ -1034,13 +1071,19 @@ def submitBackupCreation(tempStoragePath, backupName, backupPath, backupDomain):
 
         ##
 
-        if ProcessUtilities.outputExecutioner(execPath, website.externalApp).find('1,None') > -1:
+        output = ProcessUtilities.outputExecutioner(execPath, website.externalApp)
+        if output.find('1,None') > -1:
             execPath = "sudo nice -n 10 python " + virtualHostUtilities.cyberPanel + "/plogical/backupUtilities.py"
             execPath = execPath + " BackupRoot --tempStoragePath " + tempStoragePath + " --backupName " \
                        + backupName + " --backupPath " + backupPath + ' --backupDomain ' + backupDomain + ' --metaPath %s' % (
                        result[2])
 
             ProcessUtilities.executioner(execPath, 'root')
+        else:
+            logging.CyberCPLogFileWriter.writeToFile(output)
+
+        command = 'chown -R %s:%s %s' % (website.externalApp, website.externalApp, backupPath)
+        ProcessUtilities.executioner(command)
 
         command = 'rm -f %s' % (result[2])
         ProcessUtilities.executioner(command, 'cyberpanel')

plogical/dnsUtilities.py

@@ -3,13 +3,19 @@ import os,sys
 sys.path.append('/usr/local/CyberCP')
 import django
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
-django.setup()
+try:
+    django.setup()
+except:
+    pass
 import CyberCPLogFileWriter as logging
 import subprocess
 import shlex
-from dns.models import Domains,Records
+try:
-from processUtilities import ProcessUtilities
+    from dns.models import Domains,Records
-from manageServices.models import PDNSStatus, SlaveServers
+    from processUtilities import ProcessUtilities
+    from manageServices.models import PDNSStatus, SlaveServers
+except:
+    pass
 
 class DNS:
 

plogical/mailUtilities.py

@@ -2,20 +2,26 @@ import os,sys
 sys.path.append('/usr/local/CyberCP')
 import django
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
-django.setup()
+try:
+    django.setup()
+except:
+    pass
 import os.path
 import shutil
 import CyberCPLogFileWriter as logging
 import subprocess
 import argparse
 import shlex
-from mailServer.models import Domains,EUsers
-from emailPremium.models import DomainLimits, EmailLimits
-from websiteFunctions.models import Websites, ChildDomains
 from processUtilities import ProcessUtilities
 import os, getpass
 import hashlib
 import bcrypt
+try:
+    from mailServer.models import Domains, EUsers
+    from emailPremium.models import DomainLimits, EmailLimits
+    from websiteFunctions.models import Websites, ChildDomains
+except:
+    pass
 
 class mailUtilities:
 

plogical/mysqlUtilities.py

@@ -9,8 +9,11 @@ except:
 import CyberCPLogFileWriter as logging
 import subprocess
 import shlex
-from websiteFunctions.models import Websites
+try:
-from databases.models import Databases
+    from websiteFunctions.models import Websites
+    from databases.models import Databases
+except:
+    pass
 import MySQLdb as mysql
 import json
 from random import randint

plogical/remoteBackup.py

@@ -211,7 +211,7 @@ class remoteBackup:
             writeToFile.writelines("\n")
 
         except BaseException,msg:
-            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [startBackup]")
+            logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [214:startBackup]")
 
 
     @staticmethod

plogical/sslUtilities.py

@@ -4,7 +4,10 @@ import shlex
 import subprocess
 import socket
 from plogical.processUtilities import ProcessUtilities
-from websiteFunctions.models import ChildDomains, Websites
+try:
+    from websiteFunctions.models import ChildDomains, Websites
+except:
+    pass
 
 class sslUtilities:
 

plogical/vhost.py

@@ -5,14 +5,17 @@ import sys
 import django
 sys.path.append('/usr/local/CyberCP')
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
-django.setup()
+try:
+    django.setup()
+except:
+    pass
 import shutil
 import installUtilities
-from websiteFunctions.models import Websites, ChildDomains, aliasDomains
+
 import subprocess
 import shlex
 import CyberCPLogFileWriter as logging
-from databases.models import Databases
+
 from mysqlUtilities import mysqlUtilities
 from dnsUtilities import DNS
 from random import randint
@@ -20,6 +23,11 @@ from processUtilities import ProcessUtilities
 from managePHP.phpManager import PHPManager
 from vhostConfs import vhostConfs
 from ApachController.ApacheVhosts import ApacheVhost
+try:
+    from websiteFunctions.models import Websites, ChildDomains, aliasDomains
+    from databases.models import Databases
+except:
+    pass
 ## If you want justice, you have come to the wrong place.
 
 

plogical/virtualHostUtilities.py

@@ -5,7 +5,10 @@ import sys
 import django
 sys.path.append('/usr/local/CyberCP')
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
-django.setup()
+try:
+    django.setup()
+except:
+    pass
 import shutil
 import argparse
 import installUtilities
@@ -14,9 +17,6 @@ from os.path import join
 from os import listdir, rmdir
 from shutil import move
 from multiprocessing import Process
-from websiteFunctions.models import Websites, ChildDomains, aliasDomains
-from loginSystem.models import Administrator
-from packages.models import Package
 import subprocess
 import shlex
 from plogical.mailUtilities import mailUtilities
@@ -29,7 +29,14 @@ from processUtilities import ProcessUtilities
 from ApachController.ApacheController import ApacheController
 from ApachController.ApacheVhosts import ApacheVhost
 from managePHP.phpManager import PHPManager
-from CLManager.models import CLPackages
+
+try:
+    from websiteFunctions.models import Websites, ChildDomains, aliasDomains
+    from loginSystem.models import Administrator
+    from packages.models import Package
+    from CLManager.models import CLPackages
+except:
+    pass
 
 ## If you want justice, you have come to the wrong place.
 

serverStatus/serverStatusUtil.py

@@ -301,6 +301,13 @@ class ServerStatusUtil:
                     except:
                         pass
 
+            if os.path.exists('/etc/redhat-release'):
+                command = 'yum remove -y openlitespeed'
+            else:
+                command = "apt-get -y remove openlitespeed"
+
+            ServerStatusUtil.executioner(command, FNULL)
+
             logging.CyberCPLogFileWriter.statusWriter(ServerStatusUtil.lswsInstallStatusPath,
                                                       "OpenLiteSpeed removed.\n", 1)