Gecko [ aodai.devttt.com ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
__init__.py	0 B	-rw-r--r--
accept_traffic.py	5.72 KB	-rw-r--r--
cacheManager.py	6.82 KB	-rw-r--r--
client.py	1.19 KB	-rwxr-xr-x
cpecs.service	350 B	-rw-r--r--
policyCTRL.py	1.44 KB	-rw-r--r--
policyConstraint.py	1.34 KB	-rw-r--r--
startServer.py	2.72 KB	-rw-r--r--

Code Editor : cacheManager.py

#!/usr/local/CyberCP/bin/python
import os,sys
sys.path.append('/usr/local/CyberCP')
import django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
django.setup()
sys.path.append('/usr/local/CyberCP')
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
from emailPremium.models import EmailLimits, DomainLimits, Domains, EUsers

class cacheManager:
    domains = {}

@staticmethod
    def flushCache():
        try:

for domain, domainOBJ in cacheManager.domains.items():
                domaindb = Domains.objects.get(domain=domain)
                dbDomain = DomainLimits.objects.get(domain=domaindb)

dbDomain.monthlyUsed = domainOBJ.monthlyUsed
                dbDomain.save()

for email, emailOBJ in domainOBJ.emails.items():
                    emailID = EUsers.objects.get(email=email)
                    dbEmail = EmailLimits.objects.get(email=emailID)

dbEmail.monthlyUsed = emailOBJ.monthlyUsed
                    dbEmail.hourlyUsed = emailOBJ.hourlyUsed
                    dbEmail.save()

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.flushCache]')

@staticmethod
    def disableEnableLogs(self, emailAddress, operationValue):
        try:
            domainName = emailAddress.split('@')[1]

if domainName in cacheManager.domains:
                domainOBJ = cacheManager.domains[domainName]
                if emailAddress in domainOBJ.emails:
                    emailOBJ = domainOBJ.emails[emailAddress]
                    emailOBJ.logStatus = operationValue

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.disableEnableLogs]')

@staticmethod
    def purgeLog(command):
        try:
            email = command[2]
            operationVal = int(command[3])
            domain = email.split('@')[1]

if domain in cacheManager.domains:
                domainOBJ = cacheManager.domains[domain]
                emailOBJ = domainOBJ.emails[email]
                emailOBJ.logStatus = operationVal

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.purgeLog]')

@staticmethod
    def purgeLimit(command):
        try:
            email = command[2]
            operationVal = int(command[3])
            domain = email.split('@')[1]

if domain in cacheManager.domains:
                domainOBJ = cacheManager.domains[domain]
                emailOBJ = domainOBJ.emails[email]
                emailOBJ.limitStatus = operationVal

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.purgeLimit]')

@staticmethod
    def purgeLimitDomain(command):
        try:
            domain = command[2]
            operationVal = int(command[3])

if domain in cacheManager.domains:
                domainOBJ = cacheManager.domains[domain]
                domainOBJ.limitStatus = operationVal

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.purgeLimitDomain]')

@staticmethod
    def updateDomainLimit(command):
        try:
            domain = command[2]
            newLimit = int(command[3])

if domain in cacheManager.domains:
                domainOBJ = cacheManager.domains[domain]
                domainOBJ.monthlyLimits = newLimit

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.updateDomainLimit]')

@staticmethod
    def purgeLimitEmail(command):
        try:
            email = command[2]
            monthlyLimit = int(command[3])
            hourlyLimit = int(command[4])
            domain = email.split('@')[1]

if domain in cacheManager.domains:
                domainOBJ = cacheManager.domains[domain]
                emailOBJ = domainOBJ.emails[email]
                emailOBJ.monthlyLimits = monthlyLimit
                emailOBJ.hourlyLimits = hourlyLimit

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.purgeLimitEmail]')

@staticmethod
    def hourlyCleanUP():
        try:
            for domain, domainOBJ in cacheManager.domains.items():
                for email, emailOBJ in domainOBJ.emails.items():

emailID = EUsers.objects.get(email=email)
                    dbEmail = EmailLimits.objects.get(email=emailID)

dbEmail.hourlyUsed = 0
                    dbEmail.save()

dbEmail.hourlyUsed = 0
                    emailOBJ.hourlyUsed = 0

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.hourlyCleanUP]')

@staticmethod
    def monthlyCleanUP():
        try:
            # Reset email bandwidth limits
            for domain, domainOBJ in cacheManager.domains.items():
                domaindb = Domains.objects.get(domain=domain)
                dbDomain = DomainLimits.objects.get(domain=domaindb)

for email, emailOBJ in domainOBJ.emails.items():
                    emailID = EUsers.objects.get(email=email)
                    dbEmail = EmailLimits.objects.get(email=emailID)

dbEmail.monthlyUsed = 0
                    emailOBJ.monthlyUsed = 0
                    dbEmail.hourlyUsed = 0
                    emailOBJ.hourlyUsed = 0
                    dbEmail.save()

dbDomain.monthlyUsed = 0
                dbDomain.save()

# Reset website bandwidth usage
            from plogical.bandwidthReset import BandwidthReset
            BandwidthReset.resetWebsiteBandwidth()

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.monthlyCleanUP]')

@staticmethod
    def cleanUP(*args):
        cacheManager.flushCache()
        logging.writeToFile('Email Cleanup Service')
        os._exit(0)

@staticmethod
    def handlePurgeRequest(command):
        try:
            finalCommand = command.split(' ')

if finalCommand[1] == 'purgeLog':
                cacheManager.purgeLog(finalCommand)
            elif finalCommand[1] == 'purgeLimit':
                cacheManager.purgeLimit(finalCommand)
            elif finalCommand[1] == 'purgeLimitDomain':
                cacheManager.purgeLimitDomain(finalCommand)
            elif finalCommand[1] == 'updateDomainLimit':
                cacheManager.updateDomainLimit(finalCommand)
            elif finalCommand[1] == 'purgeLimitEmail':
                cacheManager.purgeLimitEmail(finalCommand)
            elif finalCommand[1] == 'hourlyCleanup':
                cacheManager.hourlyCleanUP()
            elif finalCommand[1] == 'monthlyCleanup':
                cacheManager.monthlyCleanUP()

except BaseException as msg:
            logging.writeToFile(str(msg) + ' [cacheManager.handlePurgeRequest]')

${this.title}

Code Editor : cacheManager.py