diff --git a/baseTemplate/templates/baseTemplate/index.html b/baseTemplate/templates/baseTemplate/index.html
index 506c99ed8..66026ffc3 100644
--- a/baseTemplate/templates/baseTemplate/index.html
+++ b/baseTemplate/templates/baseTemplate/index.html
@@ -95,6 +95,7 @@
+
diff --git a/cloudAPI/cloudManager.py b/cloudAPI/cloudManager.py
index 1df9c4fcd..9c86c5f09 100644
--- a/cloudAPI/cloudManager.py
+++ b/cloudAPI/cloudManager.py
@@ -1166,5 +1166,95 @@ class CloudManager:
finalData = json.dumps(finalData)
return HttpResponse(finalData)
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def addMINIONode(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'addMINIONode')
+ return s3.addMINIONode()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def fetchMINIONodes(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'fetchMINIONodes')
+ return s3.fetchMINIONodes()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def deleteMINIONode(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'deleteMINIONode')
+ return s3.deleteMINIONode()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def createPlanMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'createPlanMINIO')
+ return s3.createPlanMINIO()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def fetchBackupPlansMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'fetchBackupPlansMINIO')
+ return s3.fetchBackupPlansMINIO()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+
+ def deletePlanMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'deletePlanMINIO')
+ return s3.deletePlanMINIO()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def savePlanChangesMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'savePlanChangesMINIO')
+ return s3.savePlanChangesMINIO()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def forceRunAWSBackupMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'forceRunAWSBackupMINIO')
+ s3.start()
+ return self.ajaxPre(1, None)
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def fetchWebsitesInPlanMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'fetchWebsitesInPlanMINIO')
+ return s3.fetchWebsitesInPlanMINIO()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def fetchBackupLogsMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'fetchBackupLogsMINIO')
+ return s3.fetchBackupLogsMINIO()
+ except BaseException, msg:
+ return self.ajaxPre(0, str(msg))
+
+ def deleteDomainFromPlanMINIO(self, request):
+ try:
+ request.session['userID'] = self.admin.pk
+ s3 = S3Backups(request, self.data, 'deleteDomainFromPlanMINIO')
+ return s3.deleteDomainFromPlanMINIO()
except BaseException, msg:
return self.ajaxPre(0, str(msg))
\ No newline at end of file
diff --git a/cloudAPI/views.py b/cloudAPI/views.py
index 20494bfc6..e2c0e0a88 100644
--- a/cloudAPI/views.py
+++ b/cloudAPI/views.py
@@ -239,6 +239,28 @@ def router(request):
return cm.fetchTableData(request)
elif controller == 'fetchStructure':
return cm.fetchStructure(request)
+ elif controller == 'addMINIONode':
+ return cm.addMINIONode(request)
+ elif controller == 'fetchMINIONodes':
+ return cm.fetchMINIONodes(request)
+ elif controller == 'deleteMINIONode':
+ return cm.deleteMINIONode(request)
+ elif controller == 'createPlanMINIO':
+ return cm.createPlanMINIO(request)
+ elif controller == 'fetchBackupPlansMINIO':
+ return cm.fetchBackupPlansMINIO(request)
+ elif controller == 'deletePlanMINIO':
+ return cm.deletePlanMINIO(request)
+ elif controller == 'savePlanChangesMINIO':
+ return cm.savePlanChangesMINIO(request)
+ elif controller == 'forceRunAWSBackupMINIO':
+ return cm.forceRunAWSBackupMINIO(request)
+ elif controller == 'fetchWebsitesInPlanMINIO':
+ return cm.fetchWebsitesInPlanMINIO(request)
+ elif controller == 'fetchBackupLogsMINIO':
+ return cm.fetchBackupLogsMINIO(request)
+ elif controller == 'deleteDomainFromPlanMINIO':
+ return cm.deleteDomainFromPlanMINIO(request)
else:
return cm.ajaxPre(0, 'This function is not available in your version of CyberPanel.')
diff --git a/requirments.txt b/requirments.txt
index 2a18be448..ec761a32e 100644
--- a/requirments.txt
+++ b/requirments.txt
@@ -33,7 +33,6 @@ jsonpointer==1.9
kitchen==1.1.1
MarkupSafe==0.11
mock==2.0.0
-minio==4.0.9
parsedatetime==2.4
pbr==4.0.4
perf==0.1
diff --git a/s3Backups/models.py b/s3Backups/models.py
index 81a12de36..d57aa8af9 100644
--- a/s3Backups/models.py
+++ b/s3Backups/models.py
@@ -44,4 +44,30 @@ 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)
+
+class MINIONodes(models.Model):
+ owner = models.ForeignKey(Administrator, on_delete=models.CASCADE)
+ endPointURL = models.CharField(max_length=200, unique=True)
+ accessKey = models.CharField(max_length=200, unique=True)
+ secretKey = models.CharField(max_length=200)
+
+
+class BackupPlanMINIO(models.Model):
+ owner = models.ForeignKey(Administrator, on_delete=models.CASCADE)
+ minioNode = models.ForeignKey(MINIONodes, on_delete=models.CASCADE)
+ name = models.CharField(max_length=50, unique=True)
+ freq = models.CharField(max_length=50)
+ retention = models.IntegerField()
+ lastRun = models.CharField(max_length=50, default='0:0:0')
+
+class WebsitesInPlanMINIO(models.Model):
+ owner = models.ForeignKey(BackupPlanMINIO, on_delete=models.CASCADE)
+ domain = models.CharField(max_length=100)
+
+
+class BackupLogsMINIO(models.Model):
+ owner = models.ForeignKey(BackupPlanMINIO, on_delete=models.CASCADE)
+ timeStamp = models.CharField(max_length=200)
+ level = models.CharField(max_length=5)
msg = models.CharField(max_length=500)
\ No newline at end of file
diff --git a/s3Backups/s3Backups.py b/s3Backups/s3Backups.py
index c3f936c79..df584cea2 100644
--- a/s3Backups/s3Backups.py
+++ b/s3Backups/s3Backups.py
@@ -9,6 +9,7 @@ try:
import threading as multi
from plogical.mailUtilities import mailUtilities
import boto3
+ from minio.error import ResponseError
from boto3.s3.transfer import TransferConfig
import json
from .models import *
@@ -25,9 +26,9 @@ except:
import requests
import subprocess, shlex
-class S3Backups(multi.Thread):
- def __init__(self, request = None, data = None, function = None):
+class S3Backups(multi.Thread):
+ def __init__(self, request=None, data=None, function=None):
multi.Thread.__init__(self)
self.request = request
self.data = data
@@ -43,8 +44,10 @@ class S3Backups(multi.Thread):
self.forceRunAWSBackupDO()
elif self.function == 'runAWSBackups':
self.runAWSBackups()
+ elif self.function == 'forceRunAWSBackupMINIO':
+ self.forceRunAWSBackupMINIO()
except BaseException, msg:
- logging.writeToFile( str(msg) + ' [S3Backups.run]')
+ logging.writeToFile(str(msg) + ' [S3Backups.run]')
@staticmethod
def getPagination(records, toShow):
@@ -79,7 +82,7 @@ class S3Backups(multi.Thread):
counter = 1
for items in logs:
- dic = { 'id': items.id, 'timeStamp': items.timeStamp, 'level': items.level, 'mesg': items.msg }
+ dic = {'id': items.id, 'timeStamp': items.timeStamp, 'level': items.level, 'mesg': items.msg}
if checker == 0:
json_data = json_data + json.dumps(dic)
checker = 1
@@ -133,7 +136,8 @@ class S3Backups(multi.Thread):
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.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)
@@ -155,7 +159,6 @@ class S3Backups(multi.Thread):
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
-
s3 = boto3.resource('s3')
json_data = "["
checker = 0
@@ -190,8 +193,8 @@ class S3Backups(multi.Thread):
admin = Administrator.objects.get(pk=userID)
- newPlan = BackupPlan(owner=admin, name=self.data['planName'].replace(' ', ''), freq = self.data['frequency'],
- retention= self.data['retenion'], bucket= self.data['bucketName'])
+ newPlan = BackupPlan(owner=admin, name=self.data['planName'].replace(' ', ''), freq=self.data['frequency'],
+ retention=self.data['retenion'], bucket=self.data['bucketName'])
newPlan.save()
for items in self.data['websitesInPlan']:
@@ -216,19 +219,18 @@ class S3Backups(multi.Thread):
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.backupplan_set.all():
dic = {
- 'name': plan.name,
- 'bucket': plan.bucket,
- 'freq': plan.freq,
- 'retention': plan.retention,
- 'lastRun': plan.lastRun,
- }
+ '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)
@@ -275,16 +277,15 @@ class S3Backups(multi.Thread):
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
-
plan = BackupPlan.objects.get(name=self.data['planName'])
json_data = "["
checker = 0
for website in plan.websitesinplan_set.all():
dic = {
- 'id': website.id,
- 'domain': website.domain,
- }
+ 'id': website.id,
+ 'domain': website.domain,
+ }
if checker == 0:
json_data = json_data + json.dumps(dic)
@@ -332,8 +333,6 @@ class S3Backups(multi.Thread):
if currentACL['admin'] == 0:
return proc.ajax(0, 'Only administrators can use AWS S3 Backups.')
- logging.writeToFile('hello world')
-
changePlan = BackupPlan.objects.get(name=self.data['planName'])
changePlan.bucket = self.data['bucketName']
@@ -433,7 +432,8 @@ class S3Backups(multi.Thread):
}
)
except BaseException, msg:
- BackupLogs(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR', msg=str(msg)).save()
+ BackupLogs(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR',
+ msg=str(msg)).save()
##
@@ -441,30 +441,34 @@ class S3Backups(multi.Thread):
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 0:
- BackupLogs(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='INFO', msg='Unauthorised user tried to run AWS Backups.').save()
+ BackupLogs(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='INFO',
+ msg='Unauthorised user tried to run AWS Backups.').save()
return 0
- BackupLogs(owner=plan,level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Starting backup process..').save()
+ BackupLogs(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"),
+ msg='Starting backup process..').save()
for items in plan.websitesinplan_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,
- )
- BackupLogs(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Backup successful for ' + items.domain + '.').save()
+ result[1] + ".tar.gz",
+ bucketName,
+ key,
+ Config=config,
+ )
+ BackupLogs(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"),
+ msg='Backup successful for ' + items.domain + '.').save()
else:
- BackupLogs(owner=plan, level='ERROR', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Backup failed for ' + items.domain + '. Error: ' + result[1]).save()
-
+ BackupLogs(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()
- BackupLogs(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), msg='Backup Process Finished.').save()
+ BackupLogs(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.runBackupPlan]')
plan = BackupPlan.objects.get(name=self.data['planName'])
@@ -513,7 +517,8 @@ class S3Backups(multi.Thread):
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.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)
@@ -544,12 +549,12 @@ class S3Backups(multi.Thread):
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
- )
+ '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 = "["
@@ -586,9 +591,11 @@ class S3Backups(multi.Thread):
admin = Administrator.objects.get(pk=userID)
- newPlan = BackupPlanDO(owner=admin, name=self.data['planName'].replace(' ', ''), freq = self.data['frequency'],
- retention= self.data['retenion'], bucket= self.data['bucketName'], type= self.data['type'],
- region= self.data['region'])
+ newPlan = BackupPlanDO(owner=admin, name=self.data['planName'].replace(' ', ''),
+ 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']:
@@ -613,19 +620,18 @@ class S3Backups(multi.Thread):
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']):
+ 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,
- }
+ '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)
@@ -672,16 +678,15 @@ class S3Backups(multi.Thread):
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,
- }
+ 'id': website.id,
+ 'domain': website.domain,
+ }
if checker == 0:
json_data = json_data + json.dumps(dic)
@@ -759,8 +764,6 @@ class S3Backups(multi.Thread):
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']
@@ -828,7 +831,8 @@ class S3Backups(multi.Thread):
}
)
except BaseException, msg:
- BackupLogsDO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR', msg=str(msg)).save()
+ BackupLogsDO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR',
+ msg=str(msg)).save()
##
@@ -836,30 +840,34 @@ class S3Backups(multi.Thread):
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()
+ 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()
+ 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()
+ 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()
-
+ 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()
+ 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'])
@@ -881,14 +889,14 @@ class S3Backups(multi.Thread):
else:
if lastRunMonth == time.strftime("%m"):
days = int(time.strftime("%d")) - int(lastRunDay)
- if days >=6:
+ if days >= 6:
self.data = {}
self.data['planName'] = plan.name
self.forceRunAWSBackup()
else:
days = 30 - int(lastRunDay)
days = days + int(time.strftime("%d"))
- if days >=6:
+ if days >= 6:
self.data = {}
self.data['planName'] = plan.name
self.forceRunAWSBackup()
@@ -904,14 +912,14 @@ class S3Backups(multi.Thread):
else:
if lastRunMonth == time.strftime("%m"):
days = int(time.strftime("%d")) - int(lastRunDay)
- if days >=6:
+ 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:
+ if days >= 6:
self.data = {}
self.data['planName'] = plan.name
self.forceRunAWSBackupDO()
@@ -919,15 +927,367 @@ class S3Backups(multi.Thread):
except BaseException, msg:
logging.writeToFile(str(msg) + ' [S3Backups.runAWSBackups]')
-def main():
+ def addMINIONode(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 MINIO Backups.')
+
+ admin = Administrator.objects.get(pk=userID)
+
+ newNode = MINIONodes(owner=admin, endPointURL=self.data['endPoint'], accessKey=self.data['accessKey'],
+ secretKey=self.data['secretKey'])
+ newNode.save()
+
+ return proc.ajax(1, None)
+
+ except BaseException, msg:
+ logging.writeToFile(str(msg) + ' [addMINIONode]')
+ proc = httpProc(self.request, None, None)
+ return proc.ajax(0, str(msg))
+
+ def fetchMINIONodes(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 MINIO Backups.')
+
+ admin = Administrator.objects.get(pk=userID)
+ json_data = "["
+ checker = 0
+
+ for node in admin.minionodes_set.all():
+ dic = {
+ 'accessKey': node.accessKey,
+ 'endPoint': node.endPointURL.lstrip('https://').lstrip('http://')
+ }
+
+ 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 deleteMINIONode(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.')
+
+ delNode = MINIONodes.objects.get(accessKey=self.data['accessKey'])
+ delNode.delete()
+
+ return proc.ajax(1, None)
+
+ except BaseException, msg:
+ proc = httpProc(self.request, None, None)
+ return proc.ajax(0, str(msg))
+
+ def createPlanMINIO(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)
+
+ minioNode = MINIONodes.objects.get(accessKey=self.data['minioNode'])
+
+ newPlan = BackupPlanMINIO(owner=admin, name=self.data['planName'].replace(' ', ''),
+ freq=self.data['frequency'],
+ retention=self.data['retenion'], minioNode=minioNode)
+ newPlan.save()
+
+ for items in self.data['websitesInPlan']:
+ wp = WebsitesInPlanMINIO(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 fetchBackupPlansMINIO(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.backupplanminio_set.all():
+ dic = {
+ 'name': plan.name,
+ 'minioNode': plan.minioNode.accessKey,
+ '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 deletePlanMINIO(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 = BackupPlanMINIO.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 savePlanChangesMINIO(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.')
+
+ changePlan = BackupPlanMINIO.objects.get(name=self.data['planName'])
+ minioNode = MINIONodes.objects.get(accessKey=self.data['minioNode'].strip(' ').strip('\n'))
+
+ changePlan.minioNode = minioNode
+ changePlan.freq = self.data['frequency']
+ changePlan.retention = self.data['retention']
+
+ changePlan.save()
+
+ return proc.ajax(1, None)
+
+ except BaseException, msg:
+ proc = httpProc(self.request, None, None)
+ return proc.ajax(0, str(msg))
+
+ def forceRunAWSBackupMINIO(self):
+ try:
+
+ plan = BackupPlanMINIO.objects.get(name=self.data['planName'])
+ runTime = time.strftime("%d:%m:%Y")
+
+ ## Setup MINIO Client
+
+ endPoint = plan.minioNode.endPointURL
+ accessID = plan.minioNode.accessKey
+ secret = plan.minioNode.secretKey
+
+ session = boto3.session.Session()
+ client = session.client(
+ 's3',
+ endpoint_url= endPoint,
+ aws_access_key_id=accessID,
+ aws_secret_access_key=secret,
+ verify= False
+ )
+
+ config = TransferConfig(multipart_threshold=1024 * 25, max_concurrency=10,
+ multipart_chunksize=1024 * 25, use_threads=True)
+
+ try:
+ client.create_bucket(Bucket=plan.name.lower())
+ except BaseException, msg:
+ BackupLogsMINIO(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"),
+ msg=str(msg)).save()
+ return 0
+
+ ##
+
+ userID = self.request.session['userID']
+ currentACL = ACLManager.loadedACL(userID)
+
+ if currentACL['admin'] == 0:
+ BackupLogsMINIO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='INFO',
+ msg='Unauthorised user tried to run AWS Backups.').save()
+ return 0
+
+ BackupLogsMINIO(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"),
+ msg='Starting backup process..').save()
+
+ for items in plan.websitesinplanminio_set.all():
+ result = self.createBackup(items.domain)
+ if result[0]:
+ key = runTime + '/' + result[1].split('/')[-1] + ".tar.gz"
+
+ client.upload_file(
+ result[1] + ".tar.gz",
+ plan.name.lower(),
+ key,
+ Config=config,
+ )
+ BackupLogsMINIO(owner=plan, level='INFO', timeStamp=time.strftime("%b %d %Y, %H:%M:%S"),
+ msg='Backup successful for ' + items.domain + '.').save()
+ else:
+ BackupLogsMINIO(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()
+
+ BackupLogsMINIO(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.forceRunAWSBackupMINIO]')
+ plan = BackupPlanMINIO.objects.get(name=self.data['planName'])
+ BackupLogsMINIO(owner=plan, timeStamp=time.strftime("%b %d %Y, %H:%M:%S"), level='ERROR',
+ msg=str(msg)).save()
+
+ def fetchWebsitesInPlanMINIO(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 = BackupPlanMINIO.objects.get(name=self.data['planName'])
+ json_data = "["
+ checker = 0
+
+ for website in plan.websitesinplanminio_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 fetchBackupLogsMINIO(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 = BackupPlanMINIO.objects.get(name=self.data['planName'])
+ logs = backupPlan.backuplogsminio_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 deleteDomainFromPlanMINIO(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 = BackupPlanMINIO.objects.get(name=self.data['planName'])
+ web = WebsitesInPlanMINIO.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 main():
pathToFile = "/home/cyberpanel/" + str(randint(1000, 9999))
file = open(pathToFile, "w")
file.close()
finalData = json.dumps({'randomFile': pathToFile})
- requests.post("http://localhost:5003/api/runAWSBackups", data=finalData,verify=False)
+ requests.post("http://localhost:5003/api/runAWSBackups", data=finalData, verify=False)
+
if __name__ == "__main__":
main()
-