Nemcio/CyberPanel
1
0
Fork 0
mirror of https://github.com/usmannasir/cyberpanel.git synced 2025-11-07 22:06:05 +01:00
Code Issues Packages Projects Releases Wiki Activity

mysql tuning

Browse Source
This commit is contained in:
usmannasir
2018-12-31 22:55:17 +05:00
parent 22646cdb5c
commit 88c2e96ffd
17 changed files with 854 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/views.py
View File

@@ -570,7 +570,7 @@ def changeAdminPassword(request):
firstName="Cyber", lastName="Panel", acl=acl, token=token)
admin.save()
vers = version(currentVersion="1.7", build=5)
vers = version(currentVersion="1.7", build=6)
vers.save()
package = Package(admin=admin, packageName="Default", diskSpace=1000,

141
cloudAPI/cloudManager.py
View File

@@ -23,6 +23,7 @@ from plogical.httpProc import httpProc
from s3Backups.s3Backups import S3Backups
import os
from serverStatus.views import topProcessesStatus, killProcess
from plogical.mysqlUtilities import mysqlUtilities
class CloudManager:
def __init__(self, data=None, admin = None):
@@ -925,5 +926,145 @@ class CloudManager:
try:
request.session['userID'] = self.admin.pk
return killProcess(request)
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def connectAccountDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'connectAccountDO')
return s3.connectAccountDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def fetchBucketsDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'fetchBucketsDO')
return s3.fetchBucketsDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def createPlanDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'createPlanDO')
return s3.createPlanDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def fetchBackupPlansDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'fetchBackupPlansDO')
return s3.fetchBackupPlansDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def deletePlanDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'deletePlanDO')
return s3.deletePlanDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def fetchWebsitesInPlanDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'fetchWebsitesInPlanDO')
return s3.fetchWebsitesInPlanDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def fetchBackupLogsDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'fetchBackupLogsDO')
return s3.fetchBackupLogsDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def deleteDomainFromPlanDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'deleteDomainFromPlanDO')
return s3.deleteDomainFromPlanDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def savePlanChangesDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'savePlanChangesDO')
return s3.savePlanChangesDO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def forceRunAWSBackupDO(self, request):
try:
request.session['userID'] = self.admin.pk
s3 = S3Backups(request, self.data, 'forceRunAWSBackupDO')
s3.start()
return self.ajaxPre(1, None)
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def showStatus(self, request):
try:
request.session['userID'] = self.admin.pk
currentACL = ACLManager.loadedACL( self.admin.pk)
if currentACL['admin'] == 0:
return self.ajaxPre(0, 'Only administrators can see MySQL status.')
finalData = mysqlUtilities.showStatus()
finalData = json.dumps(finalData)
return HttpResponse(finalData)
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def fetchRam(self, request):
try:
request.session['userID'] = self.admin.pk
currentACL = ACLManager.loadedACL( self.admin.pk)
if currentACL['admin'] == 0:
return self.ajaxPre(0, 'Only administrators can see MySQL status.')
from psutil import virtual_memory
import math
finalData = {}
mem = virtual_memory()
inGB = math.ceil(float(mem.total)/float(1024 * 1024 * 1024))
finalData['ramInGB'] = inGB
finalData['conf'] = subprocess.check_output(shlex.split('sudo cat /etc/my.cnf'))
finalData['status'] = 1
finalData = json.dumps(finalData)
return HttpResponse(finalData)
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def applyMySQLChanges(self, request):
try:
request.session['userID'] = self.admin.pk
currentACL = ACLManager.loadedACL( self.admin.pk)
if currentACL['admin'] == 0:
return self.ajaxPre(0, 'Only administrators can see MySQL status.')
result = mysqlUtilities.applyMySQLChanges(self.data)
if result[0] == 0:
return self.ajaxPre(0, result[1])
else:
return self.ajaxPre(1, None)
except BaseException, msg:
return self.ajaxPre(0, str(msg))

26
cloudAPI/views.py
View File

@@ -201,6 +201,32 @@ def router(request):
return cm.systemStatus(request)
elif controller == 'killProcess':
return cm.killProcess(request)
elif controller == 'connectAccountDO':
return cm.connectAccountDO(request)
elif controller == 'fetchBucketsDO':
return cm.fetchBucketsDO(request)
elif controller == 'createPlanDO':
return cm.createPlanDO(request)
elif controller == 'fetchBackupPlansDO':
return cm.fetchBackupPlansDO(request)
elif controller == 'deletePlanDO':
return cm.deletePlanDO(request)
elif controller == 'fetchWebsitesInPlanDO':
return cm.fetchWebsitesInPlanDO(request)
elif controller == 'fetchBackupLogsDO':
return cm.fetchBackupLogsDO(request)
elif controller == 'deleteDomainFromPlanDO':
return cm.deleteDomainFromPlanDO(request)
elif controller == 'savePlanChangesDO':
return cm.savePlanChangesDO(request)
elif controller == 'forceRunAWSBackupDO':
return cm.forceRunAWSBackupDO(request)
elif controller == 'showStatus':
return cm.showStatus(request)
elif controller == 'fetchRam':
return cm.fetchRam(request)
elif controller == 'applyMySQLChanges':
return cm.applyMySQLChanges(request)
else:
return cm.ajaxPre(0, 'This function is not available in your version of CyberPanel.')

4
install/install.py
View File

@@ -780,7 +780,7 @@ class preFlightsChecks:
os.chdir(self.path)
command = "wget http://cyberpanel.sh/CyberPanel.1.7.5.tar.gz"
command = "wget http://cyberpanel.sh/CyberPanel.1.7.6.tar.gz"
#command = "wget http://cyberpanel.sh/CyberPanelTemp.tar.gz"
preFlightsChecks.call(command, self.distro, '[download_install_CyberPanel]',
'CyberPanel Download',
@@ -789,7 +789,7 @@ class preFlightsChecks:
##
count = 0
command = "tar zxf CyberPanel.1.7.5.tar.gz"
command = "tar zxf CyberPanel.1.7.6.tar.gz"
#command = "tar zxf CyberPanelTemp.tar.gz"
preFlightsChecks.call(command, self.distro, '[download_install_CyberPanel]',
'Extract CyberPanel',1, 1, os.EX_OSERR)

2
loginSystem/views.py
View File

@@ -156,7 +156,7 @@ def loadLoginPage(request):
firstName="Cyber",lastName="Panel", acl=acl, token=token)
admin.save()
vers = version(currentVersion="1.7", build=5)
vers = version(currentVersion="1.7", build=6)
vers.save()
package = Package(admin=admin, packageName="Default", diskSpace=1000,

6
managePHP/php70.xml
View File

@@ -260,4 +260,10 @@
<status>0</status>
</extension>
<extension>
<extensionName>lsphp70-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/php71.xml
View File

@@ -260,4 +260,10 @@
<status>0</status>
</extension>
<extension>
<extensionName>lsphp71-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/php72.xml
View File

@@ -260,4 +260,10 @@
<status>0</status>
</extension>
<extension>
<extensionName>lsphp72-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/php73.xml
View File

@@ -260,4 +260,10 @@
<status>0</status>
</extension>
<extension>
<extensionName>lsphp73-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/ubuntuphp70.xml
View File

@@ -110,4 +110,10 @@
<status>1</status>
</extension>
<extension>
<extensionName>lsphp70-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/ubuntuphp71.xml
View File

@@ -110,4 +110,10 @@
<status>1</status>
</extension>
<extension>
<extensionName>lsphp71-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/ubuntuphp72.xml
View File

@@ -110,4 +110,10 @@
<status>1</status>
</extension>
<extension>
<extensionName>lsphp72-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

6
managePHP/ubuntuphp73.xml
View File

@@ -110,4 +110,10 @@
<status>1</status>
</extension>
<extension>
<extensionName>lsphp73-ioncube</extensionName>
<extensionDescription>ioncube loaders</extensionDescription>
<status>0</status>
</extension>
</php>

144
plogical/mysqlUtilities.py
View File

@@ -9,7 +9,9 @@ import shlex
from websiteFunctions.models import Websites
from databases.models import Databases
import MySQLdb as mysql
import json
from random import randint
from plogical.processUtilities import ProcessUtilities
class mysqlUtilities:
@@ -192,3 +194,143 @@ class mysqlUtilities:
return website.databases_set.all()
except:
0
@staticmethod
def showStatus():
try:
connection, cursor = mysqlUtilities.setupConnection()
if connection == 0:
return 0
cursor.execute("SHOW GLOBAL STATUS")
result = cursor.fetchall()
data = {}
data['status'] = 1
for items in result:
if items[0] == 'Uptime':
data['uptime'] = mysqlUtilities.GetTime(items[1])
elif items[0] == 'Connections':
data['connections'] = items[1]
elif items[0] == 'Slow_queries':
data['Slow_queries'] = items[1]
## Process List
cursor.execute("show processlist")
result = cursor.fetchall()
json_data = "["
checker = 0
for items in result:
if len(str(items[1])) == 0:
database = 'NULL'
else:
database = items[1]
if len(str(items[6])) == 0:
state = 'NULL'
else:
state = items[6]
if len(str(items[7])) == '':
info = 'NULL'
else:
info = items[7]
dic = {
'id': items[0],
'user': items[1],
'database': database,
'command': items[4],
'time': items[5],
'state': state,
'info': info,
'progress': items[8],
}
if checker == 0:
json_data = json_data + json.dumps(dic)
checker = 1
else:
json_data = json_data + ',' + json.dumps(dic)
json_data = json_data + ']'
data['processes'] = json_data
##
return data
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg) + "[showStatus]")
return 0
@staticmethod
def GetTime(seconds):
time = float(seconds)
day = time // (24 * 3600)
time = time % (24 * 3600)
hour = time // 3600
time %= 3600
minutes = time // 60
time %= 60
seconds = time
return ("%d:%d:%d:%d" % (day, hour, minutes, seconds))
@staticmethod
def applyMySQLChanges(data):
try:
command = 'sudo mv /etc/my.cnf /etc/my.cnf.bak'
ProcessUtilities.executioner(command)
## Temp
tempPath = "/home/cyberpanel/" + str(randint(1000, 9999))
writeToFile = open(tempPath, 'w')
writeToFile.write(data['suggestedContent'])
writeToFile.close()
##
command = 'sudo mv ' + tempPath + ' /etc/my.cnf'
ProcessUtilities.executioner(command)
command = 'sudo systemctl restart mysql'
ProcessUtilities.executioner(command)
return 1, None
except BaseException, msg:
command = 'sudo mv /etc/my.cnf.bak /etc/my.cnf'
subprocess.call(shlex.split(command))
logging.CyberCPLogFileWriter.writeToFile(str(msg))
return 0, str(msg)
@staticmethod
def fetchVariables():
try:
connection, cursor = mysqlUtilities.setupConnection()
if connection == 0:
return 0
cursor.execute("SHOW VARIABLES")
result = cursor.fetchall()
for items in result:
logging.CyberCPLogFileWriter.writeToFile(str(items))
##
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg) + "[showStatus]")
return 0

51
plogical/upgrade.py
View File

@@ -359,6 +359,57 @@ WantedBy=multi-user.target"""
CONSTRAINT `s3Backups_backuplogs_owner_id_7b4653af_fk_s3Backups` FOREIGN KEY (`owner_id`) REFERENCES `s3Backups_backupplan` (`id`)
)"""
try:
cursor.execute(query)
except:
pass
query = """CREATE TABLE `s3Backups_backupplando` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(50) NOT NULL,
`bucket` varchar(50) NOT NULL,
`freq` varchar(50) NOT NULL,
`retention` int(11) NOT NULL,
`type` varchar(5) NOT NULL,
`region` varchar(5) NOT NULL,
`lastRun` varchar(50) NOT NULL,
`owner_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `name` (`name`),
KEY `s3Backups_backupplan_owner_id_1a3ec86d_fk_loginSyst` (`owner_id`),
CONSTRAINT `s3Backups_backupplan_owner_id_1a3ec86d_fk_loginSyst` FOREIGN KEY (`owner_id`) REFERENCES `loginSystem_administrator` (`id`)
)"""
try:
cursor.execute(query)
except:
pass
query = """CREATE TABLE `s3Backups_websitesinplando` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`domain` varchar(100) NOT NULL,
`owner_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
KEY `s3Backups_websitesin_owner_id_cef3ea04_fk_s3Backups` (`owner_id`),
CONSTRAINT `s3Backups_websitesin_owner_id_cef3ea04_fk_s3Backups` FOREIGN KEY (`owner_id`) REFERENCES `s3Backups_backupplando` (`id`)
)"""
try:
cursor.execute(query)
except:
pass
query = """CREATE TABLE `s3Backups_backuplogsdo` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`timeStamp` varchar(200) NOT NULL,
`level` varchar(5) NOT NULL,
`msg` varchar(500) NOT NULL,
`owner_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
KEY `s3Backups_backuplogs_owner_id_c7cb5872_fk_s3Backups` (`owner_id`),
CONSTRAINT `s3Backups_backuplogs_owner_id_c7cb5872_fk_s3Backups` FOREIGN KEY (`owner_id`) REFERENCES `s3Backups_backupplando` (`id`)
)"""
try:
cursor.execute(query)
except:

21
s3Backups/models.py
View File

@@ -23,4 +23,25 @@ class BackupLogs(models.Model):
owner = models.ForeignKey(BackupPlan,on_delete=models.CASCADE)
timeStamp = models.CharField(max_length=200)
level = models.CharField(max_length=5)
msg = models.CharField(max_length=500)
class BackupPlanDO(models.Model):
owner = models.ForeignKey(Administrator, on_delete=models.CASCADE)
name = models.CharField(max_length=50, unique=True)
bucket = models.CharField(max_length=50, default='NONE')
freq = models.CharField(max_length=50)
retention = models.IntegerField()
type = models.CharField(max_length=5, default='DO')
region = models.CharField(max_length=5)
lastRun = models.CharField(max_length=50, default='0:0:0')
class WebsitesInPlanDO(models.Model):
owner = models.ForeignKey(BackupPlanDO, on_delete=models.CASCADE)
domain = models.CharField(max_length=100)
class BackupLogsDO(models.Model):
owner = models.ForeignKey(BackupPlanDO, on_delete=models.CASCADE)
timeStamp = models.CharField(max_length=200)
level = models.CharField(max_length=5)
msg = models.CharField(max_length=500)

420
s3Backups/s3Backups.py
View File

@@ -39,6 +39,8 @@ class S3Backups(multi.Thread):
self.connectAccount()
elif self.function == 'forceRunAWSBackup':
self.forceRunAWSBackup()
elif self.function == 'forceRunAWSBackupDO':
self.forceRunAWSBackupDO()
elif self.function == 'runAWSBackups':
self.runAWSBackups()
except BaseException, msg:
@@ -468,6 +470,401 @@ class S3Backups(multi.Thread):
plan = BackupPlan.objects.get(name=self.data['planName'])
BackupLogs(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR', msg=str(msg)).save()
def connectAccountDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
mailUtilities.checkHome()
path = '/home/cyberpanel/.do'
if not os.path.exists(path):
os.mkdir(path)
credentials = path + '/credentials'
credFile = open(credentials, 'w')
credFile.write(self.data['credData'])
credFile.close()
##
cronPath = '/etc/crontab'
command = 'sudo cat ' + cronPath
output = subprocess.check_output(shlex.split(command)).split('\n')
insertCron = 1
for items in output:
if items.find('s3backups.py') > -1:
insertCron = 0
break
if insertCron:
pathToFile = "/home/cyberpanel/" + str(randint(1000, 9999))
writeToFile = open(pathToFile, 'w')
for items in output:
writeToFile.writelines(items + '\n')
writeToFile.writelines('0 0 * * * cyberpanel /usr/local/CyberCP/bin/python2 /usr/local/CyberCP/s3Backups/s3Backups.py\n')
writeToFile.close()
command = 'sudo mv ' + pathToFile + ' /etc/crontab'
ProcessUtilities.executioner(command)
return proc.ajax(1, None)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def fetchBucketsDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
filePath = '/home/cyberpanel/.do/credentials'
data = open(filePath, 'r').readlines()
accessID = data[1].split('=')[1].strip(' ').strip('\n')
secret = data[2].split('=')[1].strip(' ').strip('\n')
session = boto3.session.Session()
client = session.client(
's3',
region_name=self.data['doRegion'],
endpoint_url='https://' + self.data['doRegion'] + '.digitaloceanspaces.com',
aws_access_key_id=accessID,
aws_secret_access_key=secret
)
response = client.list_buckets()
spaces = [space['Name'] for space in response['Buckets']]
json_data = "["
checker = 0
for space in spaces:
dic = {'name': space}
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)
except BaseException, msg:
logging.writeToFile(str(msg))
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def createPlanDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
admin = Administrator.objects.get(pk=userID)
newPlan = BackupPlanDO(owner=admin, name=self.data['planName'], freq = self.data['frequency'],
retention= self.data['retenion'], bucket= self.data['bucketName'], type= self.data['type'],
region= self.data['region'])
newPlan.save()
for items in self.data['websitesInPlan']:
wp = WebsitesInPlanDO(owner=newPlan, domain=items)
wp.save()
return proc.ajax(1, None)
except BaseException, msg:
logging.writeToFile(str(msg) + ' [createPlanDO]')
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def fetchBackupPlansDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
admin = Administrator.objects.get(pk=userID)
json_data = "["
checker = 0
for plan in admin.backupplando_set.filter(type= self.data['type']):
dic = {
'name': plan.name,
'bucket': plan.bucket,
'freq': plan.freq,
'retention': plan.retention,
'lastRun': plan.lastRun,
}
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)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def deletePlanDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
delPlan = BackupPlanDO.objects.get(name=self.data['planName'])
delPlan.delete()
return proc.ajax(1, None)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def fetchWebsitesInPlanDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
plan = BackupPlanDO.objects.get(name=self.data['planName'])
json_data = "["
checker = 0
for website in plan.websitesinplando_set.all():
dic = {
'id': website.id,
'domain': website.domain,
}
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)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def fetchBackupLogsDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
recordsToShow = int(self.data['recordsToShow'])
page = int(self.data['page'])
backupPlan = BackupPlanDO.objects.get(name=self.data['planName'])
logs = backupPlan.backuplogsdo_set.all().order_by('-id')
pagination = S3Backups.getPagination(len(logs), recordsToShow)
endPageNumber, finalPageNumber = S3Backups.recordsPointer(page, recordsToShow)
jsonData = S3Backups.getLogsInJson(logs[finalPageNumber:endPageNumber])
data = {}
data['data'] = jsonData
data['pagination'] = pagination
return proc.ajax(1, None, data)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajaxPre(0, str(msg))
def deleteDomainFromPlanDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
plan = BackupPlanDO.objects.get(name=self.data['planName'])
web = WebsitesInPlanDO.objects.get(owner=plan, domain=self.data['domainName'])
web.delete()
return proc.ajax(1, None)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def savePlanChangesDO(self):
try:
proc = httpProc(self.request, None, None)
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
logging.writeToFile('hello world')
changePlan = BackupPlanDO.objects.get(name=self.data['planName'])
changePlan.bucket = self.data['bucketName']
changePlan.freq = self.data['frequency']
changePlan.retention = self.data['retention']
changePlan.region = self.data['region']
changePlan.save()
return proc.ajax(1, None)
except BaseException, msg:
proc = httpProc(self.request, None, None)
return proc.ajax(0, str(msg))
def forceRunAWSBackupDO(self):
try:
plan = BackupPlanDO.objects.get(name=self.data['planName'])
bucketName = plan.bucket.strip('\n').strip(' ')
runTime = time.strftime("%d:%m:%Y")
## Setup DO Client
filePath = '/home/cyberpanel/.do/credentials'
data = open(filePath, 'r').readlines()
accessID = data[1].split('=')[1].strip(' ').strip('\n')
secret = data[2].split('=')[1].strip(' ').strip('\n')
session = boto3.session.Session()
client = session.client(
's3',
region_name=plan.region,
endpoint_url='https://' + plan.region + '.digitaloceanspaces.com',
aws_access_key_id=accessID,
aws_secret_access_key=secret
)
config = TransferConfig(multipart_threshold=1024 * 25, max_concurrency=10,
multipart_chunksize=1024 * 25, use_threads=True)
## Set Expiration for objects
try:
client.put_bucket_lifecycle_configuration(
Bucket='string',
LifecycleConfiguration={
'Rules': [
{
'Expiration': {
'Days': plan.retention,
'ExpiredObjectDeleteMarker': True
},
'ID': plan.name,
'Prefix': '',
'Filter': {
'Prefix': plan.name + '/',
},
'Status': 'Enabled',
},
]
}
)
except BaseException, msg:
BackupLogsDO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR', msg=str(msg)).save()
##
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
BackupLogsDO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='INFO', msg='Unauthorised user tried to run AWS Backups.').save()
return 0
BackupLogsDO(owner=plan,level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Starting backup process..').save()
for items in plan.websitesinplando_set.all():
result = self.createBackup(items.domain)
if result[0]:
key = plan.name + '/' + runTime + '/' + result[1].split('/')[-1] + ".tar.gz"
client.upload_file(
result[1] + ".tar.gz",
bucketName,
key,
Config=config,
)
BackupLogsDO(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Backup successful for ' + items.domain + '.').save()
else:
BackupLogsDO(owner=plan, level='ERROR', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Backup failed for ' + items.domain + '. Error: ' + result[1]).save()
plan.lastRun = runTime
plan.save()
BackupLogsDO(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Backup Process Finished.').save()
except BaseException, msg:
logging.writeToFile(str(msg) + ' [S3Backups.forceRunAWSBackupDO]')
plan = BackupPlanDO.objects.get(name=self.data['planName'])
BackupLogsDO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR', msg=str(msg)).save()
def runAWSBackups(self):
try:
admin = Administrator.objects.get(pk=1)
@@ -496,6 +893,29 @@ class S3Backups(multi.Thread):
self.data['planName'] = plan.name
self.forceRunAWSBackup()
for plan in BackupPlanDO.objects.all():
lastRunDay = plan.lastRun.split(':')[0]
lastRunMonth = plan.lastRun.split(':')[1]
if plan.freq == 'Daily' and lastRunDay != time.strftime("%d"):
self.data = {}
self.data['planName'] = plan.name
self.forceRunAWSBackupDO()
else:
if lastRunMonth == time.strftime("%m"):
days = int(time.strftime("%d")) - int(lastRunDay)
if days >=6:
self.data = {}
self.data['planName'] = plan.name
self.forceRunAWSBackupDO()
else:
days = 30 - int(lastRunDay)
days = days + int(time.strftime("%d"))
if days >=6:
self.data = {}
self.data['planName'] = plan.name
self.forceRunAWSBackupDO()
except BaseException, msg:
logging.writeToFile(str(msg) + ' [S3Backups.runAWSBackups]')