Gecko [ aodai.devttt.com ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
migrations	[ DIR ]	drwxr-xr-x
static	[ DIR ]	drwxr-xr-x
templates	[ DIR ]	drwxr-xr-x
.DS_Store	6 KB	-rw-r--r--
__init__.py	0 B	-rw-r--r--
admin.py	89 B	-rw-r--r--
apps.py	133 B	-rw-r--r--
container.py	3.98 KB	-rw-r--r--
containerManager.py	6.58 KB	-rw-r--r--
models.py	556 B	-rw-r--r--
tests.py	86 B	-rw-r--r--
urls.py	573 B	-rw-r--r--
views.py	11.47 KB	-rw-r--r--

Code Editor : containerManager.py

from plogical.processUtilities import ProcessUtilities
import threading as multi
from plogical.acl import ACLManager
import plogical.CyberCPLogFileWriter as logging
from serverStatus.serverStatusUtil import ServerStatusUtil
import os, stat
from plogical.httpProc import httpProc

class ContainerManager(multi.Thread):
    defaultConf = """group {groupName}{
        cpu {
                cpu.cfs_quota_us = {cfs_quota_us};
                cpu.cfs_period_us = {cfs_period_us};
        }
        memory {
                memory.limit_in_bytes = {memory}m;
        }
        blkio {
                blkio.throttle.read_bps_device = "{major}:{minor}         {io}";
                blkio.throttle.write_bps_device = "{major}:{minor}         {io}";
                blkio.throttle.read_iops_device = "{major}:{minor}         {iops}";
                blkio.throttle.write_iops_device = "{major}:{minor}         {iops}";
        }
        net_cls
             {
               net_cls.classid = 0x10{net_cls};
        }
}"""

def __init__(self, request=None, templateName=None, function=None, data=None):
        multi.Thread.__init__(self)
        self.request = request
        self.templateName = templateName
        self.function = function
        self.data = data

def run(self):
        try:
            if self.function == 'submitContainerInstall':
                self.submitContainerInstall()
            elif self.function == 'addTrafficController':
                self.addTrafficController()
            elif self.function == 'removeLimits':
                self.removeLimits()
        except BaseException as msg:
            logging.CyberCPLogFileWriter.writeToFile(str(msg) + ' [ContainerManager.run]')

@staticmethod
    def fetchHexValue(count):
        hexValue = format(count, '02x')

if len(hexValue) == 1:
            return '000' + hexValue
        elif len(hexValue) == 2:
            return '00' + hexValue
        elif len(hexValue) == 3:
            return '0' + hexValue
        elif len(hexValue) == 3:
            return hexValue

@staticmethod
    def prepConf(groupName, cfs_quota_us, cfs_period_us, memory, io, iops, net_cls):
        try:
            dev = os.stat('/')[stat.ST_DEV]
            major = str(os.major(dev))
            minor = str(0)
            finalIO = str(int(io) * 1024 * 1024)

ioConf = ContainerManager.defaultConf.replace('{groupName}', groupName)
            ioConf = ioConf.replace('{cfs_quota_us}', cfs_quota_us)
            ioConf = ioConf.replace('{cfs_period_us}', cfs_period_us)
            ioConf = ioConf.replace('{memory}', memory)
            ioConf = ioConf.replace('{major}', major)
            ioConf = ioConf.replace('{minor}', minor)
            ioConf = ioConf.replace('{io}', finalIO)
            ioConf = ioConf.replace('{iops}', str(iops))
            ioConf = ioConf.replace('{net_cls}', str(net_cls))

return ioConf
        except BaseException as msg:
            logging.CyberCPLogFileWriter.writeToFile(str(msg))
            return 0

def renderC(self):

data = {}
        data['OLS'] = 0
        data['notInstalled'] = 0

if ProcessUtilities.decideServer() == ProcessUtilities.OLS:
            data['OLS'] = 1
            data['notInstalled'] = 0
            proc = httpProc(self.request, 'containerization/notAvailable.html', data, 'admin')
            return proc.render()
        elif not ProcessUtilities.containerCheck():
            data['OLS'] = 0
            data['notInstalled'] = 1
            proc = httpProc(self.request, 'containerization/notAvailable.html', data, 'admin')
            return proc.render()
        else:
            if self.data == None:
                self.data = {}
            self.data['OLS'] = 0
            self.data['notInstalled'] = 0
            proc = httpProc(self.request, self.templateName, data, 'admin')
            return proc.render()

def submitContainerInstall(self):
        try:
            userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            else:
                logging.CyberCPLogFileWriter.statusWriter(ServerStatusUtil.lswsInstallStatusPath,
                                                          'Not authorized to install container packages. [404].',
                                                          1)
                return 0

execPath = "/usr/local/CyberCP/bin/python /usr/local/CyberCP/containerization/container.py"
            execPath = execPath + " --function submitContainerInstall"
            ProcessUtilities.outputExecutioner(execPath)

except BaseException as msg:
            logging.CyberCPLogFileWriter.statusWriter(ServerStatusUtil.lswsInstallStatusPath, str(msg) + ' [404].', 1)

def restartServices(self):
        command = 'sudo systemctl restart cgconfig'
        ProcessUtilities.executioner(command)

command = 'sudo systemctl restart cgred'
        ProcessUtilities.executioner(command)

def addTrafficController(self):
        command = 'sudo tc qdisc add dev eth0 root handle 10: htb default 1000'
        #logging.CyberCPLogFileWriter.writeToFile(command)
        ProcessUtilities.executioner(command)

try:
            command = 'sudo tc class del dev eth0 classid 10:' + str(self.data['classID'])
            # logging.CyberCPLogFileWriter.writeToFile(command)
            ProcessUtilities.executioner(command)
        except:
            pass

command = 'sudo tc class add dev eth0 parent 10: classid 10:1000 htb rate 100mbit'
        #logging.CyberCPLogFileWriter.writeToFile(command)
        ProcessUtilities.executioner(command)

command = 'sudo tc class add dev eth0 parent 10: classid 10:' + str(self.data['classID']) + ' htb rate ' + str(self.data['rateLimit'])
        #logging.CyberCPLogFileWriter.writeToFile(command)
        ProcessUtilities.executioner(command)

#if str(self.data['classID']) == '1':
        #    command = 'sudo tc filter add dev eth0 parent 10: protocol ip prio 10 handle 1: cgroup'
        #else:
        #    command = 'sudo tc filter add dev eth0 parent 10:' + str(
        #        self.data['classID']) + ' protocol ip prio 10 handle 1: cgroup'

command = 'sudo tc filter add dev eth0 parent 10: protocol ip prio 10 handle 1: cgroup'
        ProcessUtilities.executioner(command)

self.restartServices()

def removeLimits(self):
        command = 'sudo tc class del dev eth0 classid 10:' + str(self.data['classID'])
        #logging.CyberCPLogFileWriter.writeToFile(command)
        ProcessUtilities.executioner(command)

self.restartServices()

${this.title}

Code Editor : containerManager.py