def manageSMTP(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadError()
website = Websites.objects.get(domain=self.domain)
emailLists = website.emaillists_set.all()
listNames = []
for items in emailLists:
listNames.append(items.listName)
return render(self.request, 'emailMarketing/manageSMTPHosts.html',
{
'listNames': listNames,
'domain': self.domain
})
except KeyError, msg:
return redirect(loadLoginPage)
def restoreSite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'restoreBackup') == 0:
return ACLManager.loadError()
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
ACLManager.executeCall(command)
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})
except BaseException, msg:
return HttpResponse(str(msg))
def versionManagment(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif currentACL['versionManagement'] == 1:
pass
else:
return ACLManager.loadError()
vers = version.objects.get(pk=1)
getVersion = requests.get('https://cyberpanel.net/version.txt')
latest = getVersion.json()
latestVersion = latest['version']
latestBuild = latest['build']
return render(request, 'baseTemplate/versionManagment.html', {'build': vers.build,
'currentVersion': vers.currentVersion,
'latestVersion': latestVersion,
'latestBuild': latestBuild})
except KeyError:
return redirect(loadLoginPage)
def changeUserACL(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
aclNames = ACLManager.unFileteredACLs()
userNames = ACLManager.findAllUsers()
return render(request, 'userManagment/changeUserACL.html', {
'aclNames': aclNames,
'usersList': userNames
})
elif currentACL['changeUserACL'] == 1:
aclNames = ACLManager.unFileteredACLs()
userNames = ACLManager.findAllUsers()
return render(request, 'userManagment/changeUserACL.html', {
'aclNames': aclNames,
'usersList': userNames
})
else:
return ACLManager.loadError()
except KeyError:
return redirect(loadLoginPage)
def getTags(self, userID=None, data=None):
try:
admin = Administrator.objects.get(pk=userID)
if admin.acl.adminStatus != 1:
return ACLManager.loadError()
image = data['image']
page = data['page']
if ":" in image:
image2 = image.split(":")[0] + "/" + image.split(":")[1]
else:
image2 = "library/" + image
print image
registryData = requests.get('https://registry.hub.docker.com/v2/repositories/' + image2 + '/tags',
{'page': page}).json()
tagList = []
for tag in registryData['results']:
tagList.append(tag['name'])
data_ret = {'getTagsStatus': 1, 'list': tagList, 'next': registryData['next'], 'error_message': None}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'getTagsStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def configservercsfiframe(request):
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
if request.method == 'GET':
qs = request.GET.urlencode()
elif request.method == 'POST':
qs = request.POST.urlencode()
try:
tmp = tempfile.NamedTemporaryFile(mode="w", delete=False)
tmp.write(qs)
tmp.close()
command = "/usr/local/csf/bin/cyberpanel.pl '" + tmp.name + "'"
try:
output = ProcessUtilities.outputExecutioner(command)
except:
output = "Output Error from csf UI script"
os.unlink(tmp.name)
except:
output = "Unable to create csf UI temp file"
return HttpResponse(output)
def submitZoneDeletion(self, userID=None, data=None):
try:
zoneDomain = data['zoneDomain']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.currentContextPermission(currentACL,
'deleteZone') == 0:
return ACLManager.loadErrorJson('delete_status', 0)
if ACLManager.checkOwnershipZone(zoneDomain, admin,
currentACL) == 1:
pass
else:
return ACLManager.loadError()
delZone = Domains.objects.get(name=zoneDomain)
admin = Administrator.objects.get(pk=userID)
if currentACL['admin'] == 1:
if delZone.admin != admin:
return ACLManager.loadErrorJson()
delZone.delete()
final_dic = {'delete_status': 1, 'error_message': "None"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'delete_status': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def renderC(self):
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
data = {}
data['OLS'] = 0
data['notInstalled'] = 0
if ProcessUtilities.decideServer() == ProcessUtilities.OLS:
data['OLS'] = 1
data['notInstalled'] = 0
return render(self.request, 'containerization/notAvailable.html', data)
elif not ProcessUtilities.containerCheck():
data['OLS'] = 0
data['notInstalled'] = 1
return render(self.request, 'containerization/notAvailable.html', data)
else:
if self.data == None:
self.data = {}
self.data['OLS'] = 0
self.data['notInstalled'] = 0
return render(self.request, self.templateName, self.data)
def emailPage(request, emailAddress):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
Data = {}
Data['emailAddress'] = emailAddress
email = EUsers.objects.get(email=emailAddress)
logEntries = email.emaillogs_set.all().count()
pages = float(logEntries) / float(10)
pagination = []
if pages <= 1.0:
pages = 1
pagination.append('<li><a href="\#"></a></li>')
else:
pages = ceil(pages)
finalPages = int(pages) + 1
for i in range(1, finalPages):
pagination.append('<li><a href="\#">' + str(i) + '</a></li>')
Data['pagination'] = pagination
return render(request, 'emailPremium/emailPage.html', Data)
except KeyError:
return redirect(loadLoginPage)
def renderC(self):
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
data = {}
data['CL'] = 0
data['CAGEFS'] = 0
CLPath = '/etc/sysconfig/cloudlinux'
CageFSPath = '/usr/sbin/cagefsctl'
if os.path.exists(CLPath):
data['CL'] = 1
if os.path.exists(CageFSPath):
data['CAGEFS'] = 1
if data['CL'] == 0:
return render(self.request, 'CLManager/notAvailable.html', data)
elif data['CAGEFS'] == 0:
return render(self.request, 'CLManager/notAvailable.html', data)
else:
return render(self.request, self.templateName, self.data)
def removeImage(self, userID=None, data=None):
try:
admin = Administrator.objects.get(pk=userID)
if admin.acl.adminStatus != 1:
return ACLManager.loadError()
client = docker.from_env()
dockerAPI = docker.APIClient()
name = data['name']
try:
if name == 0:
action = client.images.prune()
else:
action = client.images.remove(name)
print action
except docker.errors.APIError as err:
data_ret = {'removeImageStatus': 0, 'error_message': str(err)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except:
data_ret = {'removeImageStatus': 0, 'error_message': 'Unknown'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
data_ret = {'removeImageStatus': 1, 'error_message': 'None'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'removeImageStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def resellerCenter(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
userNames = ACLManager.loadDeletionUsers(userID, currentACL)
resellerPrivUsers = ACLManager.userWithResellerPriv(userID)
return render(
request, 'userManagment/resellerCenter.html', {
'userToBeModified': userNames,
'resellerPrivUsers': resellerPrivUsers
})
elif currentACL['resellerCenter'] == 1:
userNames = ACLManager.loadDeletionUsers(userID, currentACL)
resellerPrivUsers = ACLManager.userWithResellerPriv(userID)
return render(
request, 'userManagment/resellerCenter.html', {
'userToBeModified': userNames,
'resellerPrivUsers': resellerPrivUsers
})
else:
return ACLManager.loadError()
except KeyError:
return redirect(loadLoginPage)
def createFTPAccount(sender, **kwargs):
from loginSystem.models import Administrator
from plogical.acl import ACLManager
try:
request = kwargs['request']
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createFTPAccount') == 0:
return ACLManager.loadError()
admin = Administrator.objects.get(pk=userID)
if not os.path.exists('/home/cyberpanel/pureftpd'):
return render(request, "ftp/createFTPAccount.html", {"status": 0})
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'beautifulNames/createFTPAccount.html', {
'websiteList': websitesName,
'admin': admin.userName,
"status": 1
})
except BaseException, msg:
return HttpResponse(str(msg))
def restoreRemoteBackups(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createBackup') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
destinations = []
path = '/home/cyberpanel/sftp'
if os.path.exists(path):
for items in os.listdir(path):
destinations.append('sftp:%s' % (items))
path = '/home/cyberpanel/aws'
if os.path.exists(path):
for items in os.listdir(path):
destinations.append('s3:s3.amazonaws.com/%s' % (items))
return defRenderer(request, 'IncBackups/restoreRemoteBackups.html', {
'websiteList': websitesName,
'destinations': destinations
})
except BaseException, msg:
logging.writeToFile(str(msg))
return redirect(loadLoginPage)
def services(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
data = {}
if ProcessUtilities.decideServer() == ProcessUtilities.OLS:
data['serverName'] = 'OpenLiteSpeed'
else:
data['serverName'] = 'LiteSpeed Ent'
dockerInstallPath = '/usr/bin/docker'
if not os.path.exists(dockerInstallPath):
data['isDocker'] = False
else:
data['isDocker'] = True
return render(request, 'serverStatus/services.html', data)
except KeyError:
return redirect(loadLoginPage)
def manageImages(self, request=None, userID=None, data=None):
try:
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
client = docker.from_env()
dockerAPI = docker.APIClient()
imageList = client.images.list()
images = {}
names = []
for image in imageList:
try:
name = image.attrs['RepoTags'][0].split(":")[0]
if name in names:
images[name]['tags'].extend(image.tags)
else:
names.append(name)
images[name] = {"name": name,
"tags": image.tags}
except:
continue
return render(request, 'dockerManager/manageImages.html', {"images": images})
except BaseException, msg:
return HttpResponse(str(msg))
def createEmailList(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadError()
return render(self.request, 'emailMarketing/createEmailList.html', {'domain': self.domain})
except KeyError, msg:
return redirect(loadLoginPage)
def listDomains(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
try:
websites = DomainLimits.objects.all()
## Check if Policy Server is installed.
command = 'sudo cat /etc/postfix/main.cf'
output = subprocess.check_output(shlex.split(command)).split('\n')
installCheck = 0
for items in output:
if items.find(
'check_policy_service unix:/var/log/policyServerSocket'
) > -1:
installCheck = 1
break
if installCheck == 0:
return render(request, 'emailPremium/listDomains.html',
{"installCheck": installCheck})
###
pages = float(len(websites)) / float(10)
pagination = []
if pages <= 1.0:
pages = 1
pagination.append('<li><a href="\#"></a></li>')
else:
pages = ceil(pages)
finalPages = int(pages) + 1
for i in range(1, finalPages):
pagination.append('<li><a href="\#">' + str(i) +
'</a></li>')
return render(request, 'emailPremium/listDomains.html', {
"pagination": pagination,
"installCheck": installCheck
})
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
return HttpResponse("See CyberCP main log file.")
except KeyError:
return redirect(loadLoginPage)
def configservercsf(request):
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
return render(request, 'configservercsf/index.html')
def dockerPermission(request, userID, context):
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] != 1:
if request.method == "POST":
return ACLManager.loadErrorJson()
else:
return ACLManager.loadError()
else:
return 0
def backupSite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createBackup') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'backup/backup.html', {'websiteList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
def backupDestinations(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'addDeleteDestinations') == 0:
return ACLManager.loadError()
return render(request, 'backup/backupDestinations.html', {})
except BaseException, msg:
return HttpResponse(str(msg))
def createNewACL(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
return render(request, 'userManagment/createACL.html')
else:
return ACLManager.loadError()
except KeyError:
return redirect(loadLoginPage)
def createContainer(self, request=None, userID=None, data=None):
try:
admin = Administrator.objects.get(pk=userID)
if admin.acl.adminStatus != 1:
return ACLManager.loadError()
client = docker.from_env()
dockerAPI = docker.APIClient()
adminNames = ACLManager.loadAllUsers(userID)
tag = request.GET.get('tag')
image = request.GET.get('image')
tag = tag.split(" (")[0]
if "/" in image:
name = image.split("/")[0] + "." + image.split("/")[1]
else:
name = image
try:
inspectImage = dockerAPI.inspect_image(image + ":" + tag)
except docker.errors.ImageNotFound:
val = request.session['userID']
admin = Administrator.objects.get(pk=val)
return render(request, 'dockerManager/images.html', {"type": admin.type,
'image': image,
'tag': tag})
envList = {};
if 'Env' in inspectImage['Config']:
for item in inspectImage['Config']['Env']:
if '=' in item:
splitedItem = item.split('=', 1)
print splitedItem
envList[splitedItem[0]] = splitedItem[1]
else:
envList[item] = ""
portConfig = {};
if 'ExposedPorts' in inspectImage['Config']:
for item in inspectImage['Config']['ExposedPorts']:
portDef = item.split('/')
portConfig[portDef[0]] = portDef[1]
if image is None or image is '' or tag is None or tag is '':
return redirect(loadImages)
Data = {"ownerList": adminNames, "image": image, "name": name, "tag": tag, "portConfig": portConfig,
"envList": envList}
return render(request, 'dockerManager/runContainer.html', Data)
except BaseException, msg:
return HttpResponse(str(msg))
def remoteBackups(self, request, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'remoteBackups') == 0:
return ACLManager.loadError()
return render(request, 'backup/remoteBackups.html')
except BaseException, msg:
return HttpResponse(str(msg))
def emailLimits(request, domain):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
if Websites.objects.filter(domain=domain).exists():
website = Websites.objects.get(domain=domain)
domainEmail = Domains.objects.get(domainOwner=website)
domainLimits = DomainLimits.objects.get(domain=domainEmail)
Data = {}
Data['domain'] = domain
Data['monthlyLimit'] = domainLimits.monthlyLimit
Data['monthlyUsed'] = domainLimits.monthlyUsed
Data['emailAccounts'] = domainEmail.eusers_set.count()
if domainLimits.limitStatus == 1:
Data['limitsOn'] = 1
Data['limitsOff'] = 0
else:
Data['limitsOn'] = 0
Data['limitsOff'] = 1
## Pagination for emails
pages = float(Data['emailAccounts']) / float(10)
pagination = []
if pages <= 1.0:
pages = 1
pagination.append('<li><a href="\#"></a></li>')
else:
pages = ceil(pages)
finalPages = int(pages) + 1
for i in range(1, finalPages):
pagination.append('<li><a href="\#">' + str(i) +
'</a></li>')
Data['pagination'] = pagination
return render(request, 'emailPremium/emailLimits.html', Data)
else:
return render(request, 'emailPremium/emailLimits.html', {
"error": 1,
"domain": "This domain does not exists"
})
except KeyError:
return redirect(loadLoginPage)
def renderDM(self):
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
return render(self.request, self.templateName, self.data)
def submitFTPCreation(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createFTPAccount') == 0:
return ACLManager.loadErrorJson('creatFTPStatus', 0)
data = json.loads(self.request.body)
userName = data['ftpUserName']
password = data['passwordByPass']
domainName = data['ftpDomain']
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(domainName, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
try:
api = data['api']
except:
api = '0'
admin = Administrator.objects.get(id=userID)
try:
path = data['path']
if len(path) > 0:
pass
else:
path = 'None'
except:
path = 'None'
result = FTPUtilities.submitFTPCreation(domainName, userName, password, path, admin.userName, api)
if result[0] == 1:
data_ret = {'status': 1, 'creatFTPStatus': 1, 'error_message': 'None'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {'status': 0, 'creatFTPStatus': 0, 'error_message': result[1]}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'creatFTPStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def liteSpeedTuning(self, request, userID):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
return render(request, 'tuning/liteSpeedTuning.html', {})
except KeyError:
return redirect(loadLoginPage)
def loadContainerHome(self, request=None, userID=None, data=None):
name = self.name
if ACLManager.checkContainerOwnership(name, userID) != 1:
return ACLManager.loadError()
client = docker.from_env()
dockerAPI = docker.APIClient()
try:
container = client.containers.get(name)
except docker.errors.NotFound as err:
return HttpResponse("Container not found")
data = {}
con = Containers.objects.get(name=name)
data['name'] = name
data['image'] = con.image + ":" + con.tag
data['ports'] = json.loads(con.ports)
data['cid'] = con.cid
data['envList'] = json.loads(con.env)
data['volList'] = json.loads(con.volumes)
stats = container.stats(decode=False, stream=False)
logs = container.logs(stream=True)
data['status'] = container.status
data['memoryLimit'] = con.memory
if con.startOnReboot == 1:
data['startOnReboot'] = 'true'
data['restartPolicy'] = "Yes"
else:
data['startOnReboot'] = 'false'
data['restartPolicy'] = "No"
if 'usage' in stats['memory_stats']:
# Calculate Usage
# Source: https://github.com/docker/docker/blob/28a7577a029780e4533faf3d057ec9f6c7a10948/api/client/stats.go#L309
data['memoryUsage'] = (stats['memory_stats']['usage'] / stats['memory_stats']['limit']) * 100
cpu_count = len(stats["cpu_stats"]["cpu_usage"]["percpu_usage"])
data['cpuUsage'] = 0.0
cpu_delta = float(stats["cpu_stats"]["cpu_usage"]["total_usage"]) - \
float(stats["precpu_stats"]["cpu_usage"]["total_usage"])
system_delta = float(stats["cpu_stats"]["system_cpu_usage"]) - \
float(stats["precpu_stats"]["system_cpu_usage"])
if system_delta > 0.0:
data['cpuUsage'] = round(cpu_delta / system_delta * 100.0 * cpu_count, 3)
else:
data['memoryUsage'] = 0
data['cpuUsage'] = 0
return render(request, 'dockerManager/viewContainer.html', data)