def claimApp(self):
try:
_res = riaps_sudo('chown -R %s:%s %s' % (self.userName,self.userName,self.appFolder))
_res = riaps_sudo('chown %s %s/%s' % (Config.TARGET_USER,self.appFolder,const.appDescFile))
except:
# traceback.print_exc()
self.logger.warning('claiming app for user %s failed' % (self.userName))
self.userName = Config.TARGET_USER # Default user
def reclaimApp(self):
try:
riaps_user = Config.TARGET_USER
_res = riaps_sudo('chown -R %s:%s %s' % (riaps_user,riaps_user,self.appFolder))
except:
traceback.print_exc()
pass
def __init__(self, context):
self.logger = logging.getLogger(__name__)
self.appID = 1 # App ID counter
# Map of apps
self.appMap = {}
# Context
self.context = context
# Cgroups
self.cgroupTree = trees.Tree()
if self.cgroupTree.get_node_by_path('/cpu/riaps/') == None:
self.logger.info("attempting to create cgroup 'riaps'")
_res = riaps_sudo('user_cgroups %s' % (Config.TARGET_USER))
self.cgroupTree = trees.Tree()
self.riapsCPU = self.cgroupTree.get_node_by_path(
'/cpu/riaps/') # CPU scheduling
self.riapsMem = self.cgroupTree.get_node_by_path(
'/memory/riaps/') # Memory usage
self.riapsNet = self.cgroupTree.get_node_by_path(
'/net_cls/riaps/') # Net usage
self.hasCGroup = (self.riapsCPU is not None) and \
(self.riapsMem is not None) and \
(self.riapsNet is not None)
if not self.hasCGroup:
self.logger.warning(
"cgroup 'riaps' is incomplete - limited resource management.")
# File space is handled through the quota system
self.spcMonitor = SpcMonitorThread(self)
self.spcMonitor.start()
# Network limits are handled through tc
self.cleanupNet()
riaps_user = Config.TARGET_USER
pw_record = pwd.getpwnam(riaps_user)
self.riaps_uid = str(pw_record.pw_uid)
_res = riaps_sudo(
'tc qdisc add dev %s root handle %s: htb' # Root qdisc = htb
% (Config.NIC_NAME, self.riaps_uid))
_res = riaps_sudo('tc class add dev %s parent %s: ' # Root class
'classid %s:%s htb rate %s ceil %s' %
(Config.NIC_NAME, self.riaps_uid, self.riaps_uid,
self.riaps_uid, Config.NIC_RATE, Config.NIC_CEIL))
self.netMonitor = NetMonitorThread(self)
self.netMonitor.start()
self.logger.info("__init__ed")
def setupNet(self):
self.hasRate = None
if 'net' not in self.settings:
self.logger.info("actor.setupNet: no 'net' setting")
return False
self.netSettings = self.settings['net']
if 'rate' not in self.netSettings:
self.logger.info("actor.setupNet: no 'rate' setting")
return False
self.netRate = self.netSettings['rate']
self.netCeil = self.netSettings['ceil']
self.netBurst = self.netSettings['burst']
self.hasRate = True
if self.netCGroup:
self.netController = self.netCGroup.controller
major = self.parent.uid
parentID = str(major)
self.actorID = self.parent.nextActorID()
childID = str(self.actorID)
minor = self.actorID
classid = (major << 16) | minor
self.netController.class_id = classid
try:
# tc class add dev enp0s3 parent 1002: classid 1002:2 htb rate 100kbps ceil 110kbps
cmd = ('tc class add dev %s parent %s: classid %s:%s htb rate %sbps ' \
% (Config.NIC_NAME,parentID,parentID,childID,self.netRate)) + \
("" if self.netCeil == 0 else "ceil %sbps " % (self.netCeil)) + \
("" if self.netBurst == 0 else "burst %s" % (self.netBurst))
_res = riaps_sudo(cmd)
# tc filter add dev enp0s3 parent 1002:1 protocol ip prio 10 handle 1: cgroup
cmd = "tc filter add dev %s parent %s:%s protocol ip prio 10 handle %s: cgroup" \
% (Config.NIC_NAME,parentID,childID,childID)
_res = riaps_sudo(cmd)
except:
self.logger.info("actor.setupNet: exception while setting'tc'")
return False
# Create net monitor here
else:
self.logger.info("actor.setupNet: no netCGroup")
return False
return True
def cleanupApp(self):
for actor in self.actors.values():
actor.cleanupActor()
# Delete app cgroups
try:
if self.cpuCGroup is not None:
self.cpuCGroup.delete_empty_children()
self.parent.riapsCPU.delete_cgroup(self.appName)
if self.memCGroup is not None:
self.memCGroup.delete_empty_children()
self.parent.riapsMem.delete_cgroup(self.appName)
if self.netCGroup is not None:
self.netCGroup.delete_empty_children()
self.parent.riapsNet.delete_cgroup(self.appName)
except:
pass
self.delQuota()
riaps_uid = self.parent.riaps_uid
try:
# tc qdisc del dev enp0s3 parent 1000:1001 handle 1001:
_res = riaps_sudo('tc qdisc del dev %s parent %s:%s handle %s:' %
(Config.NIC_NAME, riaps_uid, self.uid, self.uid))
# tc class del dev enp0s3 parent 1000:1000 classid 1000:1001
_res = riaps_sudo(
'tc class del dev %s parent %s:%s classid %s:%s' %
(Config.NIC_NAME, riaps_uid, riaps_uid, riaps_uid, self.uid))
except:
pass
try:
if self.userName != Config.TARGET_USER:
_res = riaps_sudo('deluser %s' % self.userName)
_res = riaps_sudo('delgroup %s' % self.userName)
riaps_user = Config.TARGET_USER
_res = riaps_sudo('chown -R %s:%s %s' %
(riaps_user, riaps_user, self.appFolder))
except:
traceback.print_exc()
pass
def delQuota(self):
if self.userName != Config.TARGET_USER: # Don't set quotas for the default user
if self.spcUsage != 0:
try:
softblock = 0
hardblock = 0
softinode = 0
hardinode = 0
command = 'setquota -u %s %d %d %d %d /' % (
self.userName, softblock, hardblock, softinode,
hardinode)
self.logger.info('exec: %s' % command)
_res = riaps_sudo(command)
except:
self.logger.warning('re-setting quota failed')
def addQuota(self,usage):
self.spcUsage += usage
if self.userName != Config.TARGET_USER: # Don't set quotas for the default user
if self.spcUsage != 0:
# Assume here that the spcUsage value is in 1024 byte blocks
try:
softblock = int(0.9 * self.spcUsage)
hardblock = self.spcUsage
softinode = 100000
hardinode = 100000
command = 'setquota -u %s %d %d %d %d /' % (self.userName,softblock,hardblock,softinode,hardinode)
self.logger.info('exec: %s' % command)
_res = riaps_sudo(command)
except:
self.logger.warning('setting quota failed')
def cleanupActor(self):
# Get rid of monitoring setup
if self.hasCPU:
if self.cpuMax:
if self.cpuMonitor.is_running():
self.cpuMonitor.terminate()
self.cpuMonitor.join()
self.cpuMonitor = None
else:
if self.parent.cpuCGroup:
try:
self.parent.cpuCGroup.delete_cgroup(self.actorName)
except:
pass
if self.hasMem:
if self.memMonitor.is_running():
self.memMonitor.terminate()
self.memMonitor.join()
self.memMonitor = None
if self.parent.memCGroup:
try:
self.parent.memCGroup.delete_cgroup(self.actorName)
except:
pass
if self.hasNet:
if self.parent.netCGroup:
try:
self.parent.netCGroup.delete_cgroup(self.actorName)
except:
pass
major = self.parent.uid
parentID = str(major)
childID = str(self.actorID)
try:
# tc class del dev enp0s3 parent 1002: classid 1002:2
cmd = ('tc class del dev %s parent %s: classid %s:%s' \
% (Config.NIC_NAME,parentID,parentID,childID))
_res = riaps_sudo(cmd)
# # tc filter add dev enp0s3 parent 1002:1 protocol ip prio 10 handle 1: cgroup
# cmd = "tc filter add dev %s parent %s:%s protocol ip prio 10 handle %s: cgroup" \
# % (Config.NIC_NAME,parentID,childID,childID)
# _res = riaps_sudo(cmd)
except:
pass
def cleanupNet(self):
_res = riaps_sudo('tc qdisc del dev %s root' %
(Config.NIC_NAME)) # Cleanup
def __init__(self, parent, appName, appFolder, userName):
self.logger = logging.getLogger(__name__)
self.parent = parent
self.context = self.parent.context
self.appName = appName
self.userName = userName
self.appFolder = appFolder
self.actors = {}
self.cgroupTree = parent.cgroupTree
self.cpuCGroup = None
self.memCGroup = None
self.netCGroup = None
self.actorID = 1
# Check if cgroup already exist, use it or create a new one.
if self.parent.riapsCPU:
# CPU
cpuPath = self.parent.riapsCPU.path + ('/' +
appName).encode('utf-8')
cpuNode = self.parent.cgroupTree.get_node_by_path(cpuPath)
self.cpuCGroup = cpuNode if (
cpuNode != None) else self.parent.riapsCPU.create_cgroup(
self.appName)
if self.parent.riapsMem:
# Memory
memPath = self.parent.riapsMem.path + ('/' +
appName).encode('utf-8')
memNode = self.parent.cgroupTree.get_node_by_path(memPath)
self.memCGroup = memNode if (
memNode != None) else self.parent.riapsMem.create_cgroup(
self.appName)
# Set up the data space for the app
self.uid = -1
try:
self.uid = getpwnam(self.userName).pw_uid # Known uid
except:
pass
if self.uid == -1: # Unknown uid
try:
time.sleep(random.random()) # Hack to avoid sim. adduser-s
_res = riaps_sudo(
'adduser --disabled-login --gecos GECOS --no-create-home %s'
% self.userName)
self.uid = getpwnam(self.userName).pw_uid
except:
# traceback.print_exc()
self.logger.warning('creating app user %s failed' %
(self.userName))
self.userName = Config.TARGET_USER # Default user
self.uid = os.getuid()
_res = riaps_sudo('chown -R %s:%s %s' %
(self.userName, self.userName, self.appFolder))
_res = riaps_sudo('chmod o-rwx %s' % self.appFolder)
# _res = riaps_sudo('chown %s %s/%s' % (Config.TARGET_USER,self.appFolder,const.appDescFile))
self.spcUsage = 0
self.spcMonitor = self.parent.spcMonitor
# Set up the net limits for the app
riaps_uid = self.parent.riaps_uid
try:
# tc class add dev enp0s3 parent 1000:1000 classid 1000:1001 htb rate 1000kbps ceil 1100kbps
_res = riaps_sudo(
'tc class add dev %s parent %s:%s '
'classid %s:%s htb rate %s ceil %s' %
(Config.NIC_NAME, riaps_uid, riaps_uid, riaps_uid, self.uid,
Config.NIC_RATE,
Config.NIC_CEIL)) # Give the full bandwidth for the app
# tc qdisc add dev enp0s3 parent 1000:1001 handle 1001: htb
_res = riaps_sudo(
'tc qdisc add dev %s parent %s:%s handle %s: htb' %
(Config.NIC_NAME, riaps_uid, self.uid, self.uid))
except:
pass
if self.parent.riapsNet:
# Net cls
netPath = self.parent.riapsNet.path + ('/' +
appName).encode('utf-8')
netNode = self.parent.cgroupTree.get_node_by_path(netPath)
self.netCGroup = netNode if (
netNode != None) else self.parent.riapsNet.create_cgroup(
self.appName)
else:
pass
self.netMonitor = self.parent.netMonitor
