def get(self, request, format=None):
psMemCpuInfo = {}
commands_MEM = "ps -aux|sort -k4nr|grep -v 'USER'|head -n 1"
commands_CPU = "ps -aux|sort -k3nr|grep -v 'USER'|head -n 1"
try:
ps_MEM_info = functions.launchcmd(commands_MEM).readline()
ps_CPU_info = functions.launchcmd(commands_CPU).readline()
logger.debug("ps_MEM_info ===> " + ps_MEM_info)
logger.debug("ps_CPU_info ===> " + ps_CPU_info)
psMemCpuInfo["psmeminfo"] = format_process_info(ps_MEM_info)
if psMemCpuInfo["psmeminfo"]["pid"].isdigit() and psutil.pid_exists(int(psMemCpuInfo["psmeminfo"]["pid"])):
psMemCpuInfo["psmeminfo"]["name"] = psutil.Process(int(psMemCpuInfo["psmeminfo"]["pid"])).name()
else:
psMemCpuInfo["psmeminfo"]["name"] = ""
psMemCpuInfo["pscpuinfo"] = format_process_info(ps_CPU_info)
if psMemCpuInfo["pscpuinfo"]["pid"].isdigit() and psutil.pid_exists(int(psMemCpuInfo["pscpuinfo"]["pid"])):
psMemCpuInfo["pscpuinfo"]["name"] = psutil.Process(int(psMemCpuInfo["pscpuinfo"]["pid"])).name()
else:
psMemCpuInfo["pscpuinfo"]["name"] = ""
except Exception, exception:
logger.error("PsCpuMemInfo error! ===> " + exception.message)
return Response(psMemCpuInfo, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_udp_info(cls):
"""
get udp info
:return:
"""
udp_info = {}
try:
logger.debug("udp begin:======>")
rtinfo = functions.launchcmd('sar -n UDP 1 1').readlines()
logger.debug("commands finished! ")
if rtinfo:
continue_falg = True
for item in rtinfo:
if continue_falg:
if "idgm" in item:
continue_falg = False
continue
tmplist = item.split()
udp_info["time"] = tmplist[0]
udp_info["idgm/s"] = tmplist[1]
udp_info["odgm/s"] = tmplist[2]
udp_info["noport/s"] = tmplist[3]
udp_info["idgmerr/s"] = tmplist[4]
break
except IOError, e:
logger.error(e.message, e)
return False, udp_info
def get_socket_info(cls):
"""
get socket info
:return:
"""
socket_info = {}
try:
logger.debug("socket begin:======>")
rtinfo = functions.launchcmd('sar -n SOCK 1 1').readlines()
logger.debug("commands finished! ")
if rtinfo:
continue_falg = True
for item in rtinfo:
if continue_falg:
if "totsck" in item:
continue_falg = False
continue
tmplist = item.split()
socket_info["time"] = tmplist[0]
socket_info["totsck"] = tmplist[1]
socket_info["tcpsck"] = tmplist[2]
socket_info["udpsck"] = tmplist[3]
socket_info["rawsck"] = tmplist[4]
socket_info["ip-frag"] = tmplist[5]
socket_info["tcp-tw"] = tmplist[6]
break
except IOError, e:
logger.error(e.message, e)
return False, socket_info
def get_numastat_info(cls):
"""
get numastat info
:return:
"""
numastat_list = []
numastat = []
try:
rtninfo = functions.launchcmd('numastat').readlines()
for item in rtninfo:
items = item.split()
numastat.append(items)
logger.debug(numastat)
logger.debug(len(numastat[0]))
for i in range(0, len(numastat[0])):
numastat_info = {}
logger.debug(i)
numastat_info["name"] = numastat[0][i]
numastat_info["numa_hit"] = numastat[1][i + 1]
numastat_info["numa_miss"] = numastat[2][i + 1]
numastat_info["numa_foreign"] = numastat[3][i + 1]
numastat_info["interleave_hit"] = numastat[4][i + 1]
numastat_info["local_node"] = numastat[5][i + 1]
numastat_info["other_node"] = numastat[6][i + 1]
numastat_list.append(numastat_info)
# numastat_info["numastat_list"] = numastat_list
except IOError:
return False, numastat_list
return True, numastat_list
def get_mem_info(cls, keys):
"""
get memory info
:param keys: the items
:return:
"""
virtual_memory = {}
try:
freem = functions.launchcmd('free').readlines()
shared = int(strip(freem[1].split()[4])) * 1024
rtinfo = psutil.virtual_memory()
if rtinfo:
rtinfo_list = str(rtinfo).replace("svmem(",
"").replace(")",
"").split(",")
for item in rtinfo_list:
items = item.split("=")
if "all" in keys or [] == keys:
virtual_memory[strip(items[0])] = strip(items[1])
elif strip(items[0]) in keys:
virtual_memory[strip(items[0])] = strip(items[1])
if "all" in keys or "shared" in keys or [] == keys:
virtual_memory["shared"] = shared
except IOError:
return False, virtual_memory
return True, virtual_memory
def getcapacity(cls):
"""
Get all of the disk capacity information.
:return: boolean, dict
For getting the physical disk information, we just launch the command as
"lsblk".
"""
ni_dict = {}
ni_list = []
ni_dict[ifconfig.DISK_KEY_LIST] = ni_list
cmdout = functions.launchcmd(ifconfig.DISKINFO_CMDLINE)
if cmdout:
for line in cmdout:
# print(line)
matched_groups = re.match(ifconfig.DISK_INFO_PATTERN, line)
if matched_groups:
# print(matched_groups.groups())
ni_list.append({
ifconfig.DISK_KEY_NAME:
matched_groups.group(1),
ifconfig.DISK_KEY_CAP:
matched_groups.group(2),
ifconfig.DISK_KEY_TYPE:
matched_groups.group(3)
})
else:
return False, None
return True, ni_dict
def get(self, request, itemid, format=None):
"""
Get ps list.
"""
psInfo = []
commands = ""
num = 10
if request.GET.get("num"):
num = request.GET["num"]
if "cpu" == itemid:
commands = "pidstat | sort -k7nr |grep -v 'PID' | head -n " + str(num)
else:
commands = "ps -aux|sort -k4nr|grep -v 'USER'|head -n " + str(num)
try:
ps_info = functions.launchcmd(commands).readlines()
for psitem in ps_info:
format_iteminfo = []
if "cpu" == itemid:
format_iteminfo = format_pidstat_info(psitem)
else:
format_iteminfo = format_process_info(psitem)
if format_iteminfo["pid"].isdigit() and psutil.pid_exists(int(format_iteminfo["pid"])):
format_iteminfo["name"] = psutil.Process(int(format_iteminfo["pid"])).name()
else:
format_iteminfo["name"] = ""
psInfo.append(format_iteminfo)
except Exception, exception:
logger.error("PsInfo error! ===> " + exception.message)
def get_slab_info(cls, name, keys):
"""
get slab info
:param keys: the items
:return:
"""
slab_list = []
try:
logger.debug("slabtop begin:======>")
rtinfo = functions.launchcmd('slabtop -o').readlines()
logger.debug("commands finished! length=")
logger.debug(len(rtinfo))
if rtinfo:
continue_falg = True
if "" == name:
for item in rtinfo:
slab_info = {}
if continue_falg:
if "OBJS" in item:
continue_falg = False
continue
slab_info["name"] = item.split()[7]
slab_info["objs"] = item.split()[0]
slab_info["slabs"] = item.split()[4]
slab_info["obj_slab"] = item.split()[5]
slab_info["active"] = item.split()[1]
slab_info["obj_size"] = item.split()[3]
slab_info["use"] = item.split()[2]
slab_list.append(slab_info)
return True, slab_list
else:
slab_info = {}
slab_info_temp = {}
for item in rtinfo[7:]:
if name == item.split()[7]:
slab_info_temp["name"] = item.split()[7]
slab_info_temp["objs"] = item.split()[0]
slab_info_temp["slabs"] = item.split()[4]
slab_info_temp["obj_slab"] = item.split()[5]
slab_info_temp["active"] = item.split()[1]
slab_info_temp["obj_size"] = item.split()[3]
slab_info_temp["use"] = item.split()[2]
break
if "all" in keys:
slab_list.append(slab_info_temp)
return True, slab_info_temp
for key in keys:
slab_info[key] = slab_info_temp[key]
return True, slab_info
except IOError:
return False, slab_list
return True, slab_list
def get_throughput_info(cls):
"""
get throughput info
:return:
"""
throughput_list = {}
try:
logger.debug("throughput begin:======>")
rtinfo = functions.launchcmd('sar -n ALL 1 1').readlines()
logger.debug("commands finished! ")
if rtinfo:
continue_falg = True
falg = True
for item in rtinfo:
throughput_info = {}
if continue_falg:
if "IFACE" in item:
continue_falg = False
continue
if "rxerr" in item:
falg = False
continue
if "call" in item:
break
tmplist = item.split()
if tmplist is None or tmplist == []:
continue
if falg:
throughput_info["time"] = tmplist[0]
throughput_info["name"] = tmplist[1]
throughput_info["rxpck/s"] = tmplist[2]
throughput_info["txpck/s"] = tmplist[3]
throughput_info["rxkB/s"] = tmplist[4]
throughput_info["txkB/s"] = tmplist[5]
throughput_info["rxcmp/s"] = tmplist[6]
throughput_info["txcmp/s"] = tmplist[7]
throughput_info["rxmcst/s"] = tmplist[8]
throughput_list[tmplist[1]] = throughput_info
else:
throughput_info = throughput_list[tmplist[1]]
throughput_info["rxerr/s"] = tmplist[2]
throughput_info["txerr/s"] = tmplist[3]
throughput_info["coll/s"] = tmplist[4]
throughput_info["rxdrop/s"] = tmplist[5]
throughput_info["txdrop/s"] = tmplist[6]
throughput_info["txcarr/s"] = tmplist[7]
throughput_info["rxfram/s"] = tmplist[8]
throughput_info["rxfifo/s"] = tmplist[9]
throughput_info["txfifo/s"] = tmplist[10]
throughput_list[tmplist[1]] = throughput_info
except IOError, e:
logger.error(e.message, e)
return False, throughput_list
def get(self, request, format=None):
"""
Get pci list.
"""
# Add your code here.
pci_devices = functions.launchcmd('lspci').readlines()
pci_info = []
for pci_device in pci_devices:
pci_info.append(pci_device)
return Response(pci_info, status=status.HTTP_200_OK)
def get(self, request, format=None):
"""
Get usb list.
"""
# Add your code here.
# usbdevices=os.popen('lsusb').readlines()
usb_devices = functions.launchcmd('lsusb').readlines()
usb_info = []
for usb_device in usb_devices:
usb_info.append(usb_device)
return Response(usb_info, status=status.HTTP_200_OK)
def get_iptrafic_info(cls):
"""
get iptrafic info
:return:
"""
iptrafic_info = {}
try:
logger.debug("iptrafic begin:======>")
rtinfo = functions.launchcmd('sar -n ALL 1 1').readlines()
logger.debug("commands finished! ")
if rtinfo:
continue_falg = True
falg = True
for item in rtinfo:
if continue_falg:
if "irec" in item:
continue_falg = False
continue
if "ihdrerr" in item:
falg = False
continue
if "imsg" in item:
break
tmplist = item.split()
if tmplist is None or tmplist == []:
continue
if falg:
iptrafic_info["time"] = tmplist[0]
iptrafic_info["irec/s"] = tmplist[1]
iptrafic_info["fwddgm/s"] = tmplist[2]
iptrafic_info["idel/s"] = tmplist[3]
iptrafic_info["orq/s"] = tmplist[4]
iptrafic_info["asmrq/s"] = tmplist[5]
iptrafic_info["asmok/s"] = tmplist[6]
iptrafic_info["fragok/s"] = tmplist[7]
iptrafic_info["fragcrt/s"] = tmplist[8]
else:
iptrafic_info["ihdrerr/s"] = tmplist[1]
iptrafic_info["iadrerr/s"] = tmplist[2]
iptrafic_info["iukwnpr/s"] = tmplist[3]
iptrafic_info["idisc/s"] = tmplist[4]
iptrafic_info["odisc/s"] = tmplist[5]
iptrafic_info["onort/s"] = tmplist[6]
iptrafic_info["asmf/s"] = tmplist[7]
iptrafic_info["fragf/s"] = tmplist[8]
except IOError, e:
logger.error(e.message, e)
return False, iptrafic_info
def get_page_info(cls, keys):
"""
get page info
:param keys: the items
:return:
"""
page_memory = {}
rtn_page_memory = {}
try:
rtinfo = functions.launchcmd('sar -B 1 1').readlines()
if rtinfo[-1]:
page_list = rtinfo[-1].split()
page_memory["pgpgin"] = page_list[1]
page_memory["pgpgout"] = page_list[2]
page_memory["fault"] = page_list[3]
page_memory["majflt"] = page_list[4]
page_memory["pgfree"] = page_list[5]
page_memory["pgsteal"] = page_list[8]
rtinfo_other = functions.launchcmd('sar -R 1 1').readlines()
if rtinfo_other[-1]:
page_list_other = rtinfo_other[-1].split()
page_memory["bufpg"] = page_list_other[2]
page_memory["campg"] = page_list_other[3]
if "all" in keys or [] == keys:
return True, page_memory
else:
for key in keys:
rtn_page_memory[key] = page_memory[key]
return True, rtn_page_memory
except IOError:
return False, page_memory
return True, page_memory
def apply_modification(cls):
"""
Apply all of the modification.
:return:
"""
cmdstr = "/sbin/service iptables save && /sbin/service ip6tables save \
&& systemctl start iptables.service && systemctl start ip6tables.service"
cmdout = functions.launchcmd(cmdstr)
if cmdout:
for line in cmdout:
pass
return True, const.FW_SUCCEEDED
def get(self, request, format=None):
disk_ps_info = {}
try:
logger.debug("diskinfo begin--------------")
net_info_list = functions.launchcmd('iotop -P -b -n 1 | head -n 4').readlines()
logger.debug("net_info_list -1 ====== " + net_info_list[-1])
disk_ps_info["psdiskinfo"] = net_info_list[-1].split()[0]
logger.debug("psdiskinfo ===> " + disk_ps_info["psdiskinfo"])
if disk_ps_info["psdiskinfo"].isdigit() and psutil.pid_exists(int(disk_ps_info["psdiskinfo"])):
disk_ps_info["name"] = psutil.Process(int(disk_ps_info["psdiskinfo"])).name()
else:
disk_ps_info["name"] = ""
except Exception, exception:
logger.error("DiskIOInfo error!===>" + exception.message)
return Response(disk_ps_info, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, format=None):
"""
GET sysInfo
"""
sysinfo = {}
# CPU core num
proc_cpu_cores = functions.launchcmd(
'cat /proc/cpuinfo | grep "processor" |wc -l').readline()
# logging.debug("cpu_num = " + cpu_num)
sysinfo["cpunum"] = int(proc_cpu_cores.strip())
# install soft
return Response(sysinfo, status=status.HTTP_200_OK)
def enable_service(cls, enableflag):
"""
Enable or disable firewall service according to enableflag.
:param enableflag:
:return:
"""
cmdstr = "systemctl enable iptables.service && systemctl enable ip6tables.service "
if not enableflag:
cmdstr = "systemctl disable iptables.service && systemctl disable ip6tables.service"
cmdout = functions.launchcmd(cmdstr)
if cmdout:
for line in cmdout:
pass
return True, const.FW_SUCCEEDED
def deletelistinfo(cls, request, filename):
"""
delete one tcpwrappers rules
:param request:
:param foramt:
:return:
"""
filterfile = functions.launchcmd("cat " + filename).readlines()
delete_rules = request.data.get("deleteinfo")
delete_hostsinfo = []
for daemonline in filterfile:
# if the flag is true, then wirte this line to the file
need_write = True
rule_info = daemonline.replace(":",
"").replace(" ",
"").replace(",", "")
# find the lines that need write to the file
for delete_info in delete_rules:
delete_info = delete_info.replace(",", "").replace(" ",
"").replace(
":", "")
if strip(daemonline).startswith("#"):
need_write = True
elif rule_info == delete_info:
need_write = False
if need_write:
delete_hostsinfo.append(daemonline)
# if daemonline.find(delete_daemon) == -1:
# delete_hostsinfo.append(daemonline+'\n')
if len(delete_hostsinfo):
hosts_file = open(filename, 'w+')
hosts_file.writelines(delete_hostsinfo)
hosts_file.close()
else:
return 'error'
return 'success'
def get_tcp_info(cls):
"""
get tcp info
:return:
"""
tcp_info = {}
try:
logger.debug("tcp begin:======>")
rtinfo = functions.launchcmd('sar -n ALL 1 1').readlines()
logger.debug("commands finished! ")
if rtinfo:
continue_falg = True
falg = True
for item in rtinfo:
if continue_falg:
if "active" in item:
continue_falg = False
continue
if "atmptf" in item:
falg = False
continue
if "idgm" in item:
break
tmplist = item.split()
if tmplist is None or tmplist == []:
continue
if falg:
tcp_info["time"] = tmplist[0]
tcp_info["active/s"] = tmplist[1]
tcp_info["passive/s"] = tmplist[2]
tcp_info["iseg/s"] = tmplist[3]
tcp_info["oseg/s"] = tmplist[4]
else:
tcp_info["atmptf/s"] = tmplist[1]
tcp_info["estres/s"] = tmplist[2]
tcp_info["retrans/s"] = tmplist[3]
tcp_info["isegerr/s"] = tmplist[4]
tcp_info["orsts/s"] = tmplist[5]
except IOError, e:
logger.error(e.message, e)
return False, tcp_info
def reset_all(cls):
"""
Flush all of the firewall protocol items.
:return:
iptables --help
--flush -F [chain] Delete all rules in chain or all chains
"""
cmdstr = "systemctl stop iptables.service && systemctl stop ip6tables.service \
&& iptables --flush && ip6tables --flush \
&& /sbin/service iptables save && /sbin/service ip6tables save \
&& systemctl start iptables.service &&systemctl start ip6tables.service "
cmdout = functions.launchcmd(cmdstr)
if cmdout:
for line in cmdout:
pass
return True, const.FW_SUCCEEDED
def get_swap_info(cls, keys):
"""
get swap info
:param keys: the items
:return:
"""
swap_memory = {}
try:
rtinfo = psutil.swap_memory()
if rtinfo:
logger.debug("--------get swap memory info begin-------")
rtinfo_list = str(rtinfo).replace("sswap(",
"").replace(")",
"").split(",")
pg_in_out = functions.launchcmd('sar -W 1 1').readlines()
logger.debug("cmd:sar -W 1 1 finished")
for item in rtinfo_list:
items = item.split("=")
if ("all" in keys or [] == keys) and strip(
items[0]) in ("total", "used", "free"):
swap_memory[strip(items[0])] = strip(items[1])
elif strip(items[0]) in keys:
swap_memory[strip(items[0])] = strip(items[1])
if "all" in keys or [] == keys:
swap_memory["pswpin"] = pg_in_out[-1].split()[1]
swap_memory["pswpout"] = pg_in_out[-1].split()[2]
for key in keys:
if key == "pswpin":
swap_memory["pswpin"] = pg_in_out[-1].split()[1]
elif key == "pswpout":
swap_memory["pswpout"] = pg_in_out[-1].split()[2]
except IOError:
return False, swap_memory
return True, swap_memory
def check_exist(rule):
if rule is not None:
filterfile = functions.launchcmd("cat /etc/exports").readlines()
for daemonline in filterfile:
# newrule = strip(rule) if rule.endswith('/') else "{}/".format(rule)
# newfileline = strip(daemonline) if daemonline.endswith('/') else "{}/".format(daemonline)
if strip(daemonline) == "":
continue
newrulelist = strip(rule).split()
newfilerulelist = strip(daemonline).split()
newrulelist[0] = strip(newrulelist[0]) if newrulelist[0].endswith(
'/') else "{}/".format(newrulelist[0])
newfilerulelist[0] = strip(
newfilerulelist[0]) if newfilerulelist[0].endswith(
'/') else "{}/".format(newfilerulelist[0])
newrule = " ".join(newrulelist).split('(')
newfileline = " ".join(newfilerulelist).split('(')
if daemonline.startswith('#') and strip(newrule[0]) == strip(
newfileline[0].replace('#', '')):
return True
return False
def getlistinfo(cls, filename):
"""
read info from sys
:param filename:
:return:
"""
filterfile = functions.launchcmd('grep -v "^#" ' +
filename).readlines()
hostsinfo = []
for t in filterfile:
oneinfo = t.split(":", 2)
if len(oneinfo) == 3:
hostsinfo.append(oneinfo)
elif len(oneinfo) == 2:
oneinfo.append("")
hostsinfo.append(oneinfo)
elif len(oneinfo) == 1:
oneinfo.append("")
oneinfo.append("")
hostsinfo.append(oneinfo)
return hostsinfo
def get(self, request, format=None):
"""
GET sysInfo
"""
sysinfo = {}
# kenal version
# version = commands.getoutput('uname -r')
# version = self.commoncmd('uname -r')
version = functions.launchcmd('uname -r').readline().strip('\n')
sysinfo["version"] = version
# CPU info
# cpuInfo = commands.getoutput('cat /proc/cpuinfo |grep "name" |cut -f2 -d: |uniq')
# cpuinfo = self.commoncmd('cat /proc/cpuinfo |grep "name" |cut -f2 -d: |uniq')
cpuinfo = functions.launchcmd('cat /proc/cpuinfo |grep "name" |cut -f2 -d: |uniq').readline().strip('\n')
sysinfo["cpuInfo"] = cpuinfo
# CPU load average
# upTimeInfo = commands.getoutput('uptime')
# uptimeinfo = self.commoncmd('uptime')
uptimeinfo = functions.launchcmd('uptime').readline().strip('\n')
loadaverage = uptimeinfo.split('average:')[1]
sysinfo["loadAverage"] = loadaverage
# memory info
# freem = os.popen('free -m').readlines()
freem = functions.launchcmd('free -m').readlines()
for tempmen in freem[1:len(freem)]:
men = tempmen.split()
meninfo = {
'name': men[0],
'total': men[1],
'used': men[2],
'free': men[3]
}
sysinfo[men[0].split(':')[0]] = meninfo
# hostname
# hostname = self.commoncmd('uname -n')
hostname = functions.launchcmd('uname -n').readline().strip('\n')
sysinfo["hostname"] = hostname
# sysversion
if(os.path.exists("/etc/redhat-release")):
sysversion = functions.launchcmd('cat /etc/redhat-release').readline().strip('\n')
elif(os.path.exists("/etc/inspur-release")):
sysversion = functions.launchcmd('cat /etc/inspur-release').readline().strip('\n')
sysinfo["systemversion"] = sysversion
# starttime
# starttime = self.commoncmd('uptime -s')
starttime = functions.launchcmd('uptime -s').readline().strip('\n')
sysinfo["starttime"] = starttime
# runtime
# runtimestr = self.commoncmd('uptime -p')
runtimestr = functions.launchcmd('uptime -p').readline().strip('\n')
runtime = runtimestr[3:]
sysinfo["runningtime"] = runtime
# currenttime
# currenttime = self.commoncmd('date +%Y-%m-%d\' \'%k:%M:%S')
currenttime = functions.launchcmd('date +%Y-%m-%d\' \'%k:%M:%S').readline().strip('\n')
sysinfo["currenttime"] = currenttime
# disk info
# disklines=os.popen('df -Th').readlines()
disklines = functions.launchcmd('df -Th').readlines()
diskinfo = []
for diskline in disklines[1:len(disklines)]:
onedisk = diskline.split()
print onedisk
oneDisk = {
'Filesystem': onedisk[0],
'Type': onedisk[1],
'Size': onedisk[2],
'Used': onedisk[3],
'Avail': onedisk[4],
'Usepersent': onedisk[5],
'Mounted on': onedisk[6]
}
diskinfo.append(oneDisk)
sysinfo["diskinfo"] = diskinfo
# CPU core num
cpu_num = functions.launchcmd('cat /proc/cpuinfo |grep "physical id" |sort | uniq|wc -l').readline()
each_cpu_cores = functions.launchcmd('cat /proc/cpuinfo | grep "cpu cores"|cut -d: -f2|uniq').readline()
proc_cpu_cores = functions.launchcmd('cat /proc/cpuinfo | grep "processor" |wc -l').readline()
# logging.debug("cpu_num = " + cpu_num)
# logging.debug("each_cpu_cores = " + each_cpu_cores)
# logging.debug("proc_cpu_cores = " + proc_cpu_cores)
phy_cpu_cores = int(cpu_num) * int(each_cpu_cores)
sysinfo["phycpucores"] = phy_cpu_cores
sysinfo["proc_cpu_cores"] = proc_cpu_cores
sysinfo["cpu_num"] = cpu_num
# install soft
installsoftnum = functions.launchcmd('rpm -qa|wc -l').readline()
sysinfo["installsoftnum"] = installsoftnum
# login users
users = functions.launchcmd("who | cut -d' ' -f1 |sort | uniq").readlines()
usersinfo = ""
for user in users:
usersinfo = usersinfo + user + " "
sysinfo["users"] = usersinfo
return Response(sysinfo, status=status.HTTP_200_OK)