mirror of
https://github.com/usmannasir/cyberpanel.git
synced 2025-11-03 11:55:57 +01:00
1571 lines
58 KiB
Python
1571 lines
58 KiB
Python
# -*- coding: utf-8 -*-
|
|
from __future__ import unicode_literals
|
|
|
|
from django.shortcuts import render,redirect
|
|
from django.http import HttpResponse
|
|
# Create your views here.
|
|
from .models import DBUsers
|
|
from loginSystem.models import Administrator
|
|
import json
|
|
from websiteFunctions.models import Websites,Backups,dest,backupSchedules
|
|
import plogical.CyberCPLogFileWriter as logging
|
|
from loginSystem.views import loadLoginPage
|
|
import os
|
|
import time
|
|
import plogical.backupUtilities as backupUtil
|
|
from shutil import rmtree
|
|
import shlex
|
|
import subprocess
|
|
import signal
|
|
import requests
|
|
from baseTemplate.models import version
|
|
from plogical.virtualHostUtilities import virtualHostUtilities
|
|
from random import randint
|
|
from xml.etree.ElementTree import Element, SubElement
|
|
from xml.etree import ElementTree
|
|
from xml.dom import minidom
|
|
from dns.models import Domains,Records
|
|
from mailServer.models import Domains as eDomains
|
|
from mailServer.models import EUsers
|
|
|
|
|
|
|
|
def loadBackupHome(request):
|
|
try:
|
|
val = request.session['userID']
|
|
|
|
admin = Administrator.objects.get(pk=val)
|
|
|
|
viewStatus = 1
|
|
|
|
if admin.type == 3:
|
|
viewStatus = 0
|
|
|
|
return render(request,'backup/index.html',{"viewStatus":viewStatus})
|
|
except KeyError:
|
|
return redirect(loadLoginPage)
|
|
|
|
def restoreSite(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
admin = Administrator.objects.get(pk=request.session['userID'])
|
|
|
|
if admin.type == 1:
|
|
|
|
path = os.path.join("/home","backup")
|
|
|
|
if not os.path.exists(path):
|
|
return render(request, 'backup/restore.html')
|
|
else:
|
|
all_files = []
|
|
ext = ".tar.gz"
|
|
|
|
command = 'sudo chown -R cyberpanel:cyberpanel '+ path
|
|
|
|
cmd = shlex.split(command)
|
|
|
|
res = subprocess.call(cmd)
|
|
|
|
files = os.listdir(path)
|
|
for filename in files:
|
|
if filename.endswith(ext):
|
|
all_files.append(filename)
|
|
|
|
return render(request, 'backup/restore.html',{'backups':all_files})
|
|
|
|
else:
|
|
return HttpResponse("You should be admin to perform restores.")
|
|
|
|
except BaseException, msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg))
|
|
return HttpResponse(str(msg))
|
|
except KeyError:
|
|
return redirect(loadLoginPage)
|
|
|
|
def backupSite(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
admin = Administrator.objects.get(pk=request.session['userID'])
|
|
|
|
if admin.type == 1:
|
|
websites = Websites.objects.all()
|
|
websitesName = []
|
|
|
|
for items in websites:
|
|
websitesName.append(items.domain)
|
|
else:
|
|
if admin.type == 2:
|
|
websites = admin.websites_set.all()
|
|
admins = Administrator.objects.filter(owner=admin.pk)
|
|
websitesName = []
|
|
|
|
for items in websites:
|
|
websitesName.append(items.domain)
|
|
|
|
for items in admins:
|
|
webs = items.websites_set.all()
|
|
|
|
for web in webs:
|
|
websitesName.append(web.domain)
|
|
else:
|
|
websitesName = []
|
|
websites = Websites.objects.filter(admin=admin)
|
|
for items in websites:
|
|
websitesName.append(items.domain)
|
|
|
|
return render(request, 'backup/backup.html', {'websiteList':websitesName})
|
|
except BaseException, msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg))
|
|
return HttpResponse(str(msg))
|
|
except KeyError:
|
|
return redirect(loadLoginPage)
|
|
|
|
def getCurrentBackups(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
|
|
data = json.loads(request.body)
|
|
backupDomain = data['websiteToBeBacked']
|
|
|
|
website = Websites.objects.get(domain=backupDomain)
|
|
|
|
backups = website.backups_set.all()
|
|
|
|
|
|
json_data = "["
|
|
checker = 0
|
|
|
|
for items in backups:
|
|
if items.status == 0:
|
|
status="Pending"
|
|
else:
|
|
status="Completed"
|
|
dic = {'id': items.id,
|
|
'file': items.fileName,
|
|
'date': items.date,
|
|
'size': items.size,
|
|
'status': status
|
|
}
|
|
|
|
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({'fetchStatus': 1, 'error_message': "None","data":json_data})
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'fetchStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'fetchStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
def submitBackupCreation(request):
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
data = json.loads(request.body)
|
|
backupDomain = data['websiteToBeBacked']
|
|
|
|
website = Websites.objects.get(domain=backupDomain)
|
|
|
|
## defining paths
|
|
|
|
|
|
## /home/example.com/backup
|
|
backupPath = os.path.join("/home",backupDomain,"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)
|
|
|
|
## Generating meta
|
|
|
|
## XML Generation
|
|
|
|
metaFileXML = Element('metaFile')
|
|
|
|
child = SubElement(metaFileXML, 'masterDomain')
|
|
child.text = backupDomain
|
|
|
|
child = SubElement(metaFileXML, 'phpSelection')
|
|
child.text = website.phpSelection
|
|
|
|
child = SubElement(metaFileXML, 'externalApp')
|
|
child.text = website.externalApp
|
|
|
|
|
|
childDomains = website.childdomains_set.all()
|
|
|
|
databases = website.databases_set.all()
|
|
|
|
## Child domains XML
|
|
|
|
childDomainsXML = Element('ChildDomains')
|
|
|
|
for items in childDomains:
|
|
|
|
childDomainXML = Element('domain')
|
|
|
|
child = SubElement(childDomainXML, 'domain')
|
|
child.text = items.domain
|
|
child = SubElement(childDomainXML, 'phpSelection')
|
|
child.text = items.phpSelection
|
|
child = SubElement(childDomainXML, 'path')
|
|
child.text = items.path
|
|
|
|
childDomainsXML.append(childDomainXML)
|
|
|
|
|
|
metaFileXML.append(childDomainsXML)
|
|
|
|
## Databases XML
|
|
|
|
databasesXML = Element('Databases')
|
|
|
|
for items in databases:
|
|
dbuser = DBUsers.objects.get(user=items.dbUser)
|
|
|
|
databaseXML = Element('database')
|
|
|
|
child = SubElement(databaseXML, 'dbName')
|
|
child.text = items.dbName
|
|
child = SubElement(databaseXML, 'dbUser')
|
|
child.text = items.dbUser
|
|
child = SubElement(databaseXML, 'password')
|
|
child.text = dbuser.password
|
|
|
|
databasesXML.append(databaseXML)
|
|
|
|
metaFileXML.append(databasesXML)
|
|
|
|
## DNS Records XML
|
|
|
|
try:
|
|
dnsRecordsXML = Element("dnsrecords")
|
|
domain = Domains.objects.get(name=backupDomain)
|
|
dnsRecords = Records.objects.filter(domain_id=domain.id)
|
|
|
|
for items in dnsRecords:
|
|
dnsRecordXML = Element('dnsrecord')
|
|
|
|
child = SubElement(dnsRecordXML, 'type')
|
|
child.text = items.type
|
|
child = SubElement(dnsRecordXML, 'name')
|
|
child.text = items.name
|
|
child = SubElement(dnsRecordXML, 'content')
|
|
child.text = items.content
|
|
child = SubElement(dnsRecordXML, 'priority')
|
|
child.text = str(items.prio)
|
|
|
|
dnsRecordsXML.append(dnsRecordXML)
|
|
|
|
metaFileXML.append(dnsRecordsXML)
|
|
|
|
except BaseException,msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg))
|
|
|
|
## Email accounts XML
|
|
|
|
try:
|
|
emailRecordsXML = Element('emails')
|
|
eDomain = eDomains.objects.get(domain=backupDomain)
|
|
emailAccounts = eDomain.eusers_set.all()
|
|
|
|
for items in emailAccounts:
|
|
emailRecordXML = Element('emailAccount')
|
|
|
|
child = SubElement(emailRecordXML, 'email')
|
|
child.text = items.email
|
|
child = SubElement(emailRecordXML, 'password')
|
|
child.text = items.password
|
|
|
|
emailRecordsXML.append(emailRecordXML)
|
|
|
|
metaFileXML.append(emailRecordsXML)
|
|
|
|
except BaseException,msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg))
|
|
|
|
## Email meta generated!
|
|
|
|
|
|
def prettify(elem):
|
|
"""Return a pretty-printed XML string for the Element.
|
|
"""
|
|
rough_string = ElementTree.tostring(elem, 'utf-8')
|
|
reparsed = minidom.parseString(rough_string)
|
|
return reparsed.toprettyxml(indent=" ")
|
|
|
|
## /home/cyberpanel/1047.xml
|
|
metaPath = os.path.join("/home", "cyberpanel", str(randint(1000, 9999)) + ".xml")
|
|
|
|
xmlpretty = prettify(metaFileXML).encode('ascii', 'ignore')
|
|
metaFile = open(metaPath,'w')
|
|
metaFile.write(xmlpretty)
|
|
metaFile.close()
|
|
|
|
## meta generated
|
|
|
|
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/backupUtilities.py"
|
|
execPath = execPath + " submitBackupCreation --tempStoragePath " + tempStoragePath + " --backupName " + backupName + " --backupPath " + backupPath + " --metaPath " + metaPath
|
|
|
|
subprocess.Popen(shlex.split(execPath))
|
|
|
|
newBackup = Backups(website=website, fileName=backupName, date=time.strftime("%I-%M-%S-%a-%b-%Y"),
|
|
size=0, status=0)
|
|
newBackup.save()
|
|
|
|
time.sleep(2)
|
|
|
|
final_json = json.dumps({'metaStatus': 1, 'error_message': "None", 'tempStorage': tempStoragePath})
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException, msg:
|
|
final_dic = {'metaStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
|
|
def backupStatus(request):
|
|
try:
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
data = json.loads(request.body)
|
|
backupDomain = data['websiteToBeBacked']
|
|
|
|
status = os.path.join("/home",backupDomain,"backup/status")
|
|
|
|
## read file name
|
|
|
|
try:
|
|
backupFileNamePath = os.path.join("/home",backupDomain,"backup/backupFileName")
|
|
command = "sudo cat " + backupFileNamePath
|
|
fileName = subprocess.check_output(shlex.split(command))
|
|
except:
|
|
fileName = "Fetching.."
|
|
|
|
## file name read ends
|
|
|
|
if os.path.exists(status):
|
|
command = "sudo cat " + status
|
|
status = subprocess.check_output(shlex.split(command))
|
|
|
|
if status.find("Completed")> -1:
|
|
|
|
command = 'sudo rm -f ' + status
|
|
subprocess.call(shlex.split(command))
|
|
|
|
backupOb = Backups.objects.get(fileName=fileName)
|
|
backupOb.status = 1
|
|
|
|
## adding backup data to database.
|
|
try:
|
|
backupOb.size = str(int(float(os.path.getsize("/home/"+backupDomain+"/backup/"+fileName+".tar.gz"))/(1024.0 * 1024.0)))+"MB"
|
|
backupOb.save()
|
|
except:
|
|
backupOb.size = str(int(os.path.getsize("/home/"+backupDomain+"/backup/"+fileName+".tar.gz")))
|
|
backupOb.save()
|
|
|
|
final_json = json.dumps({'backupStatus': 1, 'error_message': "None", "status": status,"abort": 1,'fileName': fileName,})
|
|
return HttpResponse(final_json)
|
|
|
|
elif status.find("[5009]")> -1:
|
|
## removing status file, so that backup can re-run
|
|
try:
|
|
command = 'sudo rm -f ' + status
|
|
cmd = shlex.split(command)
|
|
res = subprocess.call(cmd)
|
|
|
|
backupOb = Backups.objects.get(fileName=fileName)
|
|
backupOb.delete()
|
|
except BaseException,msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [backupStatus]")
|
|
|
|
final_json = json.dumps({'backupStatus': 1,'fileName': fileName, 'error_message': "None", "status": status, "abort": 1})
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_json = json.dumps(
|
|
{'backupStatus': 1, 'error_message': "None", 'fileName': fileName, "status": status,"abort": 0})
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_json = json.dumps({'backupStatus': 0, 'error_message': "None", "status": 0,"abort": 0})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'backupStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [backupStatus]")
|
|
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'backupStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
|
|
final_json = json.dumps(final_dic)
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [backupStatus]")
|
|
return HttpResponse(final_json)
|
|
|
|
def cancelBackupCreation(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
|
|
data = json.loads(request.body)
|
|
backupCancellationDomain = data['backupCancellationDomain']
|
|
fileName = data['fileName']
|
|
|
|
|
|
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/backupUtilities.py"
|
|
|
|
execPath = execPath + " cancelBackupCreation --backupCancellationDomain " + backupCancellationDomain + " --fileName " + fileName
|
|
|
|
subprocess.call(shlex.split(execPath))
|
|
|
|
try:
|
|
backupOb = Backups.objects.get(fileName=fileName)
|
|
backupOb.delete()
|
|
except BaseException, msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [cancelBackupCreation]")
|
|
|
|
final_json = json.dumps({'abortStatus': 1, 'error_message': "None", "status": 0})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'abortStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'abortStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
def deleteBackup(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
|
|
data = json.loads(request.body)
|
|
backupID = data['backupID']
|
|
|
|
backup = Backups.objects.get(id=backupID)
|
|
domainName = backup.website.domain
|
|
|
|
path = "/home/"+domainName+"/backup/"+backup.fileName+".tar.gz"
|
|
|
|
command = 'sudo rm -f ' + path
|
|
cmd = shlex.split(command)
|
|
res = subprocess.call(cmd)
|
|
|
|
backup.delete()
|
|
|
|
|
|
final_json = json.dumps({'deleteStatus': 1, 'error_message': "None", "status": 0})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'deleteStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'deleteStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
def submitRestore(request):
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
data = json.loads(request.body)
|
|
backupFile = data['backupFile']
|
|
|
|
originalFile = "/home/backup/" + backupFile
|
|
|
|
if not os.path.exists(originalFile):
|
|
dir = data['dir']
|
|
else:
|
|
dir = "CyberPanelRestore"
|
|
|
|
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/backupUtilities.py"
|
|
|
|
execPath = execPath + " submitRestore --backupFile " + backupFile + " --dir " + dir
|
|
|
|
subprocess.Popen(shlex.split(execPath))
|
|
|
|
time.sleep(4)
|
|
|
|
final_dic = {'restoreStatus': 1, 'error_message': "None"}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException, msg:
|
|
final_dic = {'restoreStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
def restoreStatus(request):
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
data = json.loads(request.body)
|
|
backupFile = data['backupFile'].strip(".tar.gz")
|
|
|
|
path = os.path.join("/home","backup",data['backupFile'])
|
|
|
|
if os.path.exists(path):
|
|
path = os.path.join("/home","backup",backupFile)
|
|
else:
|
|
dir = data['dir']
|
|
path = "/home/backup/transfer-" + str(dir) + "/" + backupFile
|
|
|
|
if os.path.exists(path):
|
|
try:
|
|
execPath = "sudo cat " + path + "/status"
|
|
|
|
status = subprocess.check_output(shlex.split(execPath))
|
|
|
|
if status.find("Done") > -1:
|
|
|
|
command = "sudo rm -rf " + path
|
|
subprocess.call(shlex.split(command))
|
|
|
|
final_json = json.dumps(
|
|
{'restoreStatus': 1, 'error_message': "None", "status": status, 'abort': 1,'running': 'Completed'})
|
|
return HttpResponse(final_json)
|
|
elif status.find("[5009]") > -1:
|
|
## removing temporarily generated files while restoring
|
|
command = "sudo rm -rf " + path
|
|
subprocess.call(shlex.split(command))
|
|
final_json = json.dumps({'restoreStatus': 1, 'error_message': "None",
|
|
"status": status, 'abort': 1,'alreadyRunning': 0,'running': 'Error'})
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_json = json.dumps({'restoreStatus': 1, 'error_message': "None", "status": status, 'abort': 0,'running': 'Running..'})
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException,msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg))
|
|
status = "Just Started"
|
|
final_json = json.dumps({'restoreStatus': 1, 'error_message': "None", "status": status, 'abort': 0,'running': 'Running..'})
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_json = json.dumps({'restoreStatus': 1, 'error_message': "None", "status": "OK To Run",'running': 'Halted','abort': 1})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
except BaseException, msg:
|
|
final_dic = {'restoreStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
def backupDestinations(request):
|
|
try:
|
|
val = request.session['userID']
|
|
|
|
admin = Administrator.objects.get(pk=val)
|
|
|
|
if admin.type == 1:
|
|
return render(request, 'backup/backupDestinations.html', {})
|
|
else:
|
|
return HttpResponse("You should be admin to add backup destinations.")
|
|
except KeyError:
|
|
return redirect(loadLoginPage)
|
|
|
|
def submitDestinationCreation(request):
|
|
try:
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
destinations = backupUtil.backupUtilities.destinationsPath
|
|
|
|
data = json.loads(request.body)
|
|
ipAddress = data['IPAddress']
|
|
password = data['password']
|
|
port = "22"
|
|
|
|
try:
|
|
port = data['backupSSHPort']
|
|
except:
|
|
pass
|
|
|
|
if dest.objects.all().count() == 2:
|
|
final_dic = {'destStatus': 0, 'error_message': "Currently only one remote destination is allowed."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
try:
|
|
d = dest.objects.get(destLoc=ipAddress)
|
|
final_dic = {'destStatus': 0, 'error_message': "This destination already exists."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
except:
|
|
setupKeys = backupUtil.backupUtilities.setupSSHKeys(ipAddress,password,port)
|
|
|
|
if setupKeys[0] == 1:
|
|
backupUtil.backupUtilities.createBackupDir(ipAddress,port)
|
|
try:
|
|
writeToFile = open(destinations, "w")
|
|
writeToFile.writelines(ipAddress + "\n")
|
|
writeToFile.writelines(data['backupSSHPort'] + "\n")
|
|
writeToFile.close()
|
|
newDest = dest(destLoc=ipAddress)
|
|
newDest.save()
|
|
except:
|
|
writeToFile = open(destinations, "w")
|
|
writeToFile.writelines(ipAddress + "\n")
|
|
writeToFile.writelines("22"+"\n")
|
|
writeToFile.close()
|
|
newDest = dest(destLoc=ipAddress)
|
|
newDest.save()
|
|
|
|
final_dic = {'destStatus': 1, 'error_message': "None"}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_dic = {'destStatus': 0, 'error_message': setupKeys[1]}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
except BaseException,msg:
|
|
final_dic = {'destStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'destStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
def getCurrentBackupDestinations(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
records = dest.objects.all()
|
|
|
|
json_data = "["
|
|
checker = 0
|
|
|
|
for items in records:
|
|
if items.destLoc == "Home":
|
|
continue
|
|
dic = {'id': items.id,
|
|
'ip': items.destLoc,
|
|
}
|
|
|
|
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({'fetchStatus': 1, 'error_message': "None","data":json_data})
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'fetchStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'fetchStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
def getConnectionStatus(request):
|
|
try:
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
|
|
data = json.loads(request.body)
|
|
ipAddress = data['IPAddress']
|
|
|
|
checkCon = backupUtil.backupUtilities.checkConnection(ipAddress)
|
|
|
|
if checkCon[0]==1:
|
|
final_dic = {'connStatus': 1, 'error_message': "None"}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_dic = {'connStatus': 0, 'error_message': checkCon[1]}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'connStatus': 1, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'connStatus': 1, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
def deleteDestination(request):
|
|
try:
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
|
|
data = json.loads(request.body)
|
|
ipAddress = data['IPAddress']
|
|
|
|
delDest = dest.objects.get(destLoc=ipAddress)
|
|
delDest.delete()
|
|
|
|
path = "/usr/local/CyberCP/backup/"
|
|
destinations = path + "destinations"
|
|
|
|
data = open(destinations,'r').readlines()
|
|
|
|
writeToFile = open(destinations,'r')
|
|
|
|
for items in data:
|
|
if items.find(ipAddress) > -1:
|
|
continue
|
|
else:
|
|
writeToFile.writelines(items)
|
|
|
|
writeToFile.close()
|
|
|
|
## Deleting Cron Tab Entries for this destination
|
|
|
|
path = "/etc/crontab"
|
|
|
|
data = open(path, 'r').readlines()
|
|
|
|
writeToFile = open(path, 'w')
|
|
|
|
for items in data:
|
|
if items.find("backupSchedule.py") > -1:
|
|
continue
|
|
else:
|
|
writeToFile.writelines(items)
|
|
|
|
writeToFile.close()
|
|
|
|
|
|
final_dic = {'delStatus': 1, 'error_message': "None"}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'delStatus': 1, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'delStatus': 1, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
def scheduleBackup(request):
|
|
try:
|
|
val = request.session['userID']
|
|
|
|
admin = Administrator.objects.get(pk=val)
|
|
|
|
if admin.type == 1:
|
|
|
|
if dest.objects.all().count() <= 1:
|
|
try:
|
|
homeDest = dest(destLoc="Home")
|
|
homeDest.save()
|
|
except:
|
|
pass
|
|
backups = dest.objects.all()
|
|
|
|
destinations = []
|
|
|
|
for items in backups:
|
|
destinations.append(items.destLoc)
|
|
|
|
return render(request,'backup/backupSchedule.html',{'destinations':destinations})
|
|
else:
|
|
return HttpResponse("You should be admin to schedule backups.")
|
|
except KeyError:
|
|
return redirect(loadLoginPage)
|
|
|
|
|
|
def getCurrentBackupSchedules(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
records = backupSchedules.objects.all()
|
|
|
|
json_data = "["
|
|
checker = 0
|
|
|
|
for items in records:
|
|
dic = {'id': items.id,
|
|
'destLoc': items.dest.destLoc,
|
|
'frequency':items.frequency,
|
|
}
|
|
|
|
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({'fetchStatus': 1, 'error_message': "None","data":json_data})
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException,msg:
|
|
final_dic = {'fetchStatus': 0, 'error_message': str(msg)}
|
|
final_json = json.dumps(final_dic)
|
|
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_dic = {'fetchStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
|
|
final_json = json.dumps(final_dic)
|
|
return HttpResponse(final_json)
|
|
|
|
def submitBackupSchedule(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
data = json.loads(request.body)
|
|
backupDest = data['backupDest']
|
|
backupFreq = data['backupFreq']
|
|
|
|
path = "/etc/crontab"
|
|
|
|
## check if already exists
|
|
try:
|
|
schedule = backupSchedules.objects.get(frequency=backupFreq)
|
|
if schedule.dest.destLoc == backupDest:
|
|
final_json = json.dumps({'scheduleStatus': 0, 'error_message': "This schedule already exists"})
|
|
return HttpResponse(final_json)
|
|
else:
|
|
if backupDest == "Home" and backupFreq == "Daily":
|
|
cronJob = "0 3 * * 0-6 root python /usr/local/CyberCP/plogical/backupScheduleLocal.py"
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path,'a')
|
|
writeToFile.writelines(cronJob+"\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest == "Home" and backupFreq == "Weekly":
|
|
cronJob = "0 3 * * 3 root python /usr/local/CyberCP/plogical/backupScheduleLocal.py "
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest != "Home" and backupFreq == "Daily":
|
|
cronJob = "0 3 * * 0-6 root python /usr/local/CyberCP/plogical/backupSchedule.py"
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest != "Home" and backupFreq == "Weekly":
|
|
cronJob = "0 3 * * 3 root python /usr/local/CyberCP/plogical/backupSchedule.py "
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination,frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
except:
|
|
if backupDest == "Home" and backupFreq == "Daily":
|
|
cronJob = "0 3 * * 0-6 root python /usr/local/CyberCP/plogical/backupScheduleLocal.py"
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest == "Home" and backupFreq == "Weekly":
|
|
cronJob = "0 3 * * 3 root python /usr/local/CyberCP/plogical/backupScheduleLocal.py "
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest != "Home" and backupFreq == "Daily":
|
|
cronJob = "0 3 * * 0-6 root python /usr/local/CyberCP/plogical/backupSchedule.py"
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest != "Home" and backupFreq == "Weekly":
|
|
cronJob = "0 3 * * 3 root python /usr/local/CyberCP/plogical/backupSchedule.py "
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
writeToFile = open(path, 'a')
|
|
writeToFile.writelines(cronJob + "\n")
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules(dest=destination, frequency=backupFreq)
|
|
newSchedule.save()
|
|
|
|
final_json = json.dumps({'scheduleStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
|
|
except BaseException,msg:
|
|
final_json = json.dumps({'scheduleStatus': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_json = json.dumps({'scheduleStatus': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
def scheduleDelete(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
data = json.loads(request.body)
|
|
backupDest = data['destLoc']
|
|
backupFreq = data['frequency']
|
|
|
|
path = "/etc/crontab"
|
|
|
|
|
|
if backupDest == "Home" and backupFreq == "Daily":
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
data = open(path, "r").readlines()
|
|
writeToFile = open(path, 'w')
|
|
|
|
for items in data:
|
|
if items.find("0-6") > -1 and items.find("backupScheduleLocal.py") > -1:
|
|
continue
|
|
else:
|
|
writeToFile.writelines(items)
|
|
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules.objects.get(dest=destination, frequency=backupFreq)
|
|
newSchedule.delete()
|
|
|
|
final_json = json.dumps({'delStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest == "Home" and backupFreq == "Weekly":
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
data = open(path, "r").readlines()
|
|
writeToFile = open(path, 'w')
|
|
|
|
for items in data:
|
|
if items.find("* 3") > -1 and items.find("backupScheduleLocal.py") > -1:
|
|
continue
|
|
else:
|
|
writeToFile.writelines(items)
|
|
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules.objects.get(dest=destination, frequency=backupFreq)
|
|
newSchedule.delete()
|
|
|
|
final_json = json.dumps({'delStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest != "Home" and backupFreq == "Daily":
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
data = open(path, "r").readlines()
|
|
writeToFile = open(path, 'w')
|
|
|
|
for items in data:
|
|
if items.find("0-6") > -1 and items.find("backupSchedule.py") > -1:
|
|
continue
|
|
else:
|
|
writeToFile.writelines(items)
|
|
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules.objects.get(dest=destination, frequency=backupFreq)
|
|
newSchedule.delete()
|
|
|
|
final_json = json.dumps({'delStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
elif backupDest != "Home" and backupFreq == "Weekly":
|
|
|
|
virtualHostUtilities.permissionControl(path)
|
|
|
|
data = open(path, "r").readlines()
|
|
writeToFile = open(path, 'w')
|
|
|
|
for items in data:
|
|
if items.find("* 3") > -1 and items.find("backupSchedule.py") > -1:
|
|
continue
|
|
else:
|
|
writeToFile.writelines(items)
|
|
|
|
writeToFile.close()
|
|
|
|
virtualHostUtilities.leaveControl(path)
|
|
|
|
command = "sudo systemctl restart crond"
|
|
|
|
subprocess.call(shlex.split(command))
|
|
|
|
destination = dest.objects.get(destLoc=backupDest)
|
|
newSchedule = backupSchedules.objects.get(dest=destination, frequency=backupFreq)
|
|
newSchedule.delete()
|
|
|
|
final_json = json.dumps({'delStatus': 1, 'error_message': "None"})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
|
|
except BaseException,msg:
|
|
final_json = json.dumps({'delStatus': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_json = json.dumps({'delStatus': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
|
|
def remoteBackups(request):
|
|
try:
|
|
userID = request.session['userID']
|
|
|
|
admin = Administrator.objects.get(pk=userID)
|
|
|
|
if admin.type == 3:
|
|
return HttpResponse("You don't have enough priviliges to access this page.")
|
|
|
|
return render(request,'backup/remoteBackups.html')
|
|
except KeyError:
|
|
return redirect(loadLoginPage)
|
|
|
|
def submitRemoteBackups(request):
|
|
try:
|
|
if request.method == 'POST':
|
|
|
|
data = json.loads(request.body)
|
|
ipAddress = data['ipAddress']
|
|
password = data['password']
|
|
|
|
## Ask for Remote version of CyberPanel
|
|
|
|
try:
|
|
finalData = json.dumps({'username': "admin", "password": password})
|
|
|
|
url = "https://" + ipAddress + ":8090/api/cyberPanelVersion"
|
|
|
|
r = requests.post(url, data=finalData, verify=False)
|
|
|
|
data = json.loads(r.text)
|
|
|
|
if data['getVersion'] == 1:
|
|
|
|
Version = version.objects.get(pk=1)
|
|
|
|
if data['currentVersion'] == Version.currentVersion and data['build'] == Version.build:
|
|
pass
|
|
else:
|
|
data_ret = {'status': 0,
|
|
'error_message': "Your version does not match with version of remote server.",
|
|
"dir": "Null"}
|
|
data_ret = json.dumps(data_ret)
|
|
return HttpResponse(data_ret)
|
|
else:
|
|
data_ret = {'status': 0,
|
|
'error_message': "Not able to fetch version of remote server. Error Message: " + data[
|
|
'error_message'], "dir": "Null"}
|
|
data_ret = json.dumps(data_ret)
|
|
return HttpResponse(data_ret)
|
|
|
|
|
|
except BaseException, msg:
|
|
data_ret = {'status': 0,
|
|
'error_message': "Not able to fetch version of remote server. Error Message: " + str(msg),
|
|
"dir": "Null"}
|
|
data_ret = json.dumps(data_ret)
|
|
return HttpResponse(data_ret)
|
|
|
|
|
|
## Fetch public key of remote server!
|
|
|
|
finalData = json.dumps({'username': "admin", "password": password})
|
|
|
|
url = "https://" + ipAddress + ":8090/api/fetchSSHkey"
|
|
r = requests.post(url, data=finalData, verify=False)
|
|
data = json.loads(r.text)
|
|
|
|
if data['pubKeyStatus'] == 1:
|
|
pubKey = data["pubKey"].strip("\n")
|
|
else:
|
|
final_json = json.dumps({'status': 0,
|
|
'error_message': "I am sorry, I could not fetch key from remote server. Error Message: " +data['error_message']
|
|
})
|
|
return HttpResponse(final_json)
|
|
|
|
## write key
|
|
|
|
## Writing key to a temporary location, to be read later by backup process.
|
|
|
|
pathToKey = "/home/cyberpanel/" + str(randint(1000, 9999))
|
|
|
|
vhost = open(pathToKey, "w")
|
|
vhost.write(pubKey)
|
|
vhost.close()
|
|
|
|
##
|
|
|
|
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/remoteTransferUtilities.py"
|
|
execPath = execPath + " writeAuthKey --pathToKey " + pathToKey
|
|
output = subprocess.check_output(shlex.split(execPath))
|
|
|
|
if output.find("1,None") > -1:
|
|
pass
|
|
else:
|
|
final_json = json.dumps({'status': 0, 'error_message': output})
|
|
return HttpResponse(final_json)
|
|
|
|
##
|
|
|
|
try:
|
|
finalData = json.dumps({'username': "admin", "password": password})
|
|
|
|
url = "https://" + ipAddress + ":8090/api/fetchAccountsFromRemoteServer"
|
|
|
|
r = requests.post(url, data=finalData, verify=False)
|
|
|
|
data = json.loads(r.text)
|
|
|
|
if data['fetchStatus'] == 1:
|
|
json_data = data['data']
|
|
data_ret = {'status': 1, 'error_message': "None",
|
|
"dir": "Null", 'data': json_data}
|
|
data_ret = json.dumps(data_ret)
|
|
return HttpResponse(data_ret)
|
|
else:
|
|
data_ret = {'status': 0,
|
|
'error_message': "Not able to fetch accounts from remote server. Error Message: " +
|
|
data['error_message'], "dir": "Null"}
|
|
data_ret = json.dumps(data_ret)
|
|
return HttpResponse(data_ret)
|
|
except BaseException, msg:
|
|
data_ret = {'status': 0,
|
|
'error_message': "Not able to fetch accounts from remote server. Error Message: " + str(
|
|
msg), "dir": "Null"}
|
|
data_ret = json.dumps(data_ret)
|
|
return HttpResponse(data_ret)
|
|
else:
|
|
return HttpResponse("This URL only accepts POST requests")
|
|
|
|
except BaseException, msg:
|
|
final_json = json.dumps({'status': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
|
|
def starRemoteTransfer(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == 'POST':
|
|
data = json.loads(request.body)
|
|
|
|
ipAddress = data['ipAddress']
|
|
password = data['password']
|
|
accountsToTransfer = data['accountsToTransfer']
|
|
|
|
try:
|
|
|
|
ipFile = os.path.join("/etc","cyberpanel","machineIP")
|
|
f = open(ipFile)
|
|
ownIP = f.read()
|
|
|
|
finalData = json.dumps({'username': "admin", "password": password,"ipAddress": ownIP,"accountsToTransfer":accountsToTransfer})
|
|
|
|
url = "https://" + ipAddress + ":8090/api/remoteTransfer"
|
|
|
|
r = requests.post(url, data=finalData, verify=False)
|
|
|
|
data = json.loads(r.text)
|
|
|
|
|
|
if data['transferStatus'] == 1:
|
|
|
|
## Create local backup dir
|
|
|
|
localBackupDir = os.path.join("/home","backup")
|
|
|
|
if not os.path.exists(localBackupDir):
|
|
command = "sudo mkdir " + localBackupDir
|
|
subprocess.call(shlex.split(command))
|
|
|
|
## create local directory that will host backups
|
|
|
|
localStoragePath = "/home/backup/transfer-" + str(data['dir'])
|
|
|
|
## making local storage directory for backups
|
|
|
|
command = "sudo mkdir " + localStoragePath
|
|
subprocess.call(shlex.split(command))
|
|
|
|
final_json = json.dumps({'remoteTransferStatus': 1, 'error_message': "None","dir":data['dir']})
|
|
return HttpResponse(final_json)
|
|
else:
|
|
final_json = json.dumps({'remoteTransferStatus': 0, 'error_message':"Can not initiate remote transfer. Error message: "+ data['error_message']})
|
|
return HttpResponse(final_json)
|
|
|
|
except BaseException,msg:
|
|
final_json = json.dumps({'remoteTransferStatus': 0,
|
|
'error_message': "Can not initiate remote transfer. Error message: " +
|
|
str(msg)})
|
|
return HttpResponse(final_json)
|
|
|
|
|
|
|
|
except BaseException,msg:
|
|
final_json = json.dumps({'remoteTransferStatus': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
except KeyError:
|
|
final_json = json.dumps({'remoteTransferStatus': 0, 'error_message': str(msg)})
|
|
return HttpResponse(final_json)
|
|
|
|
def getRemoteTransferStatus(request):
|
|
try:
|
|
if request.method == "POST":
|
|
data = json.loads(request.body)
|
|
ipAddress = data['ipAddress']
|
|
password = data['password']
|
|
dir = data['dir']
|
|
username = "admin"
|
|
|
|
finalData = json.dumps({'dir': dir, "username":username,"password":password})
|
|
r = requests.post("https://"+ipAddress+":8090/api/FetchRemoteTransferStatus", data=finalData,verify=False)
|
|
|
|
data = json.loads(r.text)
|
|
|
|
if data['fetchStatus'] == 1:
|
|
if data['status'].find("Backups are successfully generated and received on") > -1:
|
|
|
|
data = {'remoteTransferStatus': 1, 'error_message': "None", "status": data['status'],'backupsSent': 1}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
elif data['status'].find("[5010]") > -1:
|
|
data = {'remoteTransferStatus': 0, 'error_message': data['status'],
|
|
'backupsSent': 0}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
else:
|
|
data = {'remoteTransferStatus': 1, 'error_message': "None", "status": data['status'],
|
|
'backupsSent': 0}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
else:
|
|
data = {'remoteTransferStatus': 0, 'error_message': data['error_message'],
|
|
'backupsSent': 0}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
|
|
|
|
except BaseException, msg:
|
|
data = {'remoteTransferStatus': 0, 'error_message': str(msg),'backupsSent': 0}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
|
|
|
|
def remoteBackupRestore(request):
|
|
try:
|
|
val = request.session['userID']
|
|
try:
|
|
if request.method == "POST":
|
|
data = json.loads(request.body)
|
|
backupDir = data['backupDir']
|
|
|
|
backupDirComplete = "/home/backup/transfer-"+str(backupDir)
|
|
#adminEmail = admin.email
|
|
|
|
##
|
|
|
|
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/remoteTransferUtilities.py"
|
|
|
|
execPath = execPath + " remoteBackupRestore --backupDirComplete " + backupDirComplete + " --backupDir " + str(backupDir)
|
|
|
|
subprocess.Popen(shlex.split(execPath))
|
|
|
|
time.sleep(3)
|
|
|
|
data = {'remoteRestoreStatus': 1, 'error_message': 'None'}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
|
|
##
|
|
|
|
|
|
except BaseException, msg:
|
|
data = {'remoteRestoreStatus': 0, 'error_message': str(msg)}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
|
|
except KeyError:
|
|
data_ret = {'remoteRestoreStatus': 0, 'error_message': "not logged in as admin", "existsStatus": 0}
|
|
json_data = json.dumps(data_ret)
|
|
return HttpResponse(json_data)
|
|
|
|
def localRestoreStatus(request):
|
|
try:
|
|
if request.method == "POST":
|
|
|
|
data = json.loads(request.body)
|
|
backupDir = data['backupDir']
|
|
|
|
#admin = Administrator.objects.get(userName=username)
|
|
backupLogPath = "/home/backup/transfer-"+ backupDir +"/" + "backup_log"
|
|
|
|
removalPath = "/home/backup/transfer-"+ str(backupDir)
|
|
|
|
time.sleep(3)
|
|
|
|
if os.path.isfile(backupLogPath):
|
|
command = "sudo cat " + backupLogPath
|
|
status = subprocess.check_output(shlex.split(command))
|
|
|
|
if status.find("completed[success]")>-1:
|
|
command = "sudo rm -rf " + removalPath
|
|
#subprocess.call(shlex.split(command))
|
|
data_ret = {'remoteTransferStatus': 1, 'error_message': "None", "status": status, "complete": 1}
|
|
json_data = json.dumps(data_ret)
|
|
return HttpResponse(json_data)
|
|
elif status.find("[5010]") > -1:
|
|
command = "sudo rm -rf " + removalPath
|
|
#subprocess.call(shlex.split(command))
|
|
data = {'remoteTransferStatus': 0, 'error_message': status,
|
|
"status":"None","complete":0}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
else:
|
|
data_ret = {'remoteTransferStatus': 1, 'error_message': "None", "status": status, "complete": 0}
|
|
json_data = json.dumps(data_ret)
|
|
return HttpResponse(json_data)
|
|
else:
|
|
data_ret = {'remoteTransferStatus': 0, 'error_message': "No such log found","status":"None","complete":0}
|
|
json_data = json.dumps(data_ret)
|
|
return HttpResponse(json_data)
|
|
|
|
|
|
except BaseException, msg:
|
|
data = {'remoteTransferStatus': 0,'error_message': str(msg),"status":"None","complete":0}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
|
|
def cancelRemoteBackup(request):
|
|
try:
|
|
|
|
if request.method == "POST":
|
|
|
|
data = json.loads(request.body)
|
|
ipAddress = data['ipAddress']
|
|
password = data['password']
|
|
dir = data['dir']
|
|
username = "admin"
|
|
|
|
|
|
finalData = json.dumps({'dir': dir, "username":username,"password":password})
|
|
r = requests.post("https://"+ipAddress+":8090/api/cancelRemoteTransfer", data=finalData,verify=False)
|
|
|
|
data = json.loads(r.text)
|
|
|
|
if data['cancelStatus'] == 1:
|
|
pass
|
|
else:
|
|
logging.CyberCPLogFileWriter.writeToFile("Some error cancelling at remote server, see the log file for remote server.")
|
|
|
|
path = "/home/backup/transfer-" + str(dir)
|
|
|
|
if os.path.exists(path):
|
|
try:
|
|
pathpid = path + "/pid"
|
|
|
|
pid = open(pathpid, "r").readlines()[0]
|
|
|
|
try:
|
|
os.kill(int(pid), signal.SIGKILL)
|
|
except BaseException, msg:
|
|
logging.CyberCPLogFileWriter.writeToFile(str(msg) + " [cancelRemoteBackup]")
|
|
|
|
rmtree(path)
|
|
except:
|
|
rmtree(path)
|
|
|
|
data = {'cancelStatus': 1, 'error_message': "None"}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
else:
|
|
data = {'cancelStatus': 1, 'error_message': "None"}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|
|
|
|
|
|
except BaseException, msg:
|
|
data = {'cancelStatus': 0, 'error_message': str(msg)}
|
|
json_data = json.dumps(data)
|
|
return HttpResponse(json_data)
|