#coding: utf-8
# +-------------------------------------------------------------------
# | YakPanel
# +-------------------------------------------------------------------
# | Copyright (c) 2015-2099 YakPanel(www.yakpanel.com) All rights reserved.
# +-------------------------------------------------------------------
# | Author: hwliang <hwl@yakpanel.com>
# +-------------------------------------------------------------------

#--------------------------------
# 进程监控模块
#--------------------------------
from psutil import cpu_count,pids,Process,cpu_times
from json import dumps
import os
import sys
os.chdir("/www/server/panel")
sys.path.insert(0,"class/")
import db
import time
import struct
import copy
import threading
import public
from cachelib import SimpleCache

class process_network_total:
    __pid_file = 'logs/process_network_total.pid'
    __inode_list = {}
    __net_process_list = {}
    __net_process_size = {}
    __last_stat = 0
    __last_write_time = 0
    __last_check_time = 0
    __tip_file = 'data/is_net_task.pl'
    __all_tip = 'data/control.conf'

    def install_pcap(self):
        '''
            @name 安装pcap模块依赖包
            @author hwliang
            @return void
        '''
        # 标记只安装一次
        tip_file= '{}/data/install_pcap.pl'.format(public.get_panel_path())
        if os.path.exists(tip_file): return

        if os.path.exists('/usr/bin/apt'):
            os.system("apt install libpcap-dev -y")
        elif os.path.exists('/usr/bin/dnf'):
            red_file = '/etc/redhat-release'
            if os.path.exists(red_file):
                f = open(red_file,'r')
                red_body = f.read()
                f.close()
                if red_body.find('CentOS Linux release 8.') != -1:
                    rpm_file = '/root/libpcap-1.9.1.rpm'
                    down_url = "wget -O {} https://node.yakpanel.com/src/libpcap-devel-1.9.1-5.el8.x86_64.rpm  --no-check-certificate -T 10".format(
                        rpm_file)
                    if os.path.exists(rpm_file):
                        os.system(down_url)
                        os.system("rpm -ivh {}".format(rpm_file))
                    if os.path.exists(rpm_file): os.remove(rpm_file)
                else:
                    os.system("dnf install libpcap-devel -y")
            else:
                os.system("dnf install libpcap-devel -y")
        elif os.path.exists('/usr/bin/yum'):
            os.system("yum install libpcap-devel -y")
        os.system("btpip install pypcap")
        # 写入标记文件
        public.writeFile(tip_file, 'True')

    def start(self):
        '''
            @name 启动进程网络监控
            @author hwliang<2021-09-13>
            @return void
        '''
        try:
            import pcap
        except ImportError:
            try:
                self.install_pcap()
                import pcap
            except ImportError:
                print("pypcap module install failed.")
                return
        try:
            p = pcap.pcap() # 监听所有网卡
            p.setfilter('tcp') # 只监听TCP数据包
            for p_time,p_data in p:
                # 检查是否停止
                if p_time - self.__last_check_time > 10:
                    if not os.path.exists(self.__tip_file) or not os.path.exists(self.__all_tip): break

                # 处理数据包
                self.handle_packet(p_data)
        except:
            pass

    def handle_packet(self, pcap_data):
        '''
            @name 处理pcap数据包
            @author hwliang<2021-09-12>
            @param pcap_data<bytes> pcap数据包
            @return void
        '''
        # 获取IP协议头
        ip_header = pcap_data[14:34]
        # 解析src/dst地址
        src_ip = ip_header[12:16]
        dst_ip = ip_header[16:20]
        # 解析sport/dport端口
        src_port = pcap_data[34:36]
        dst_port = pcap_data[36:38]

        src = src_ip + b':' + src_port
        dst = dst_ip + b':' + dst_port
        # 计算数据包长度
        pack_size = len(pcap_data)
        # 统计进程流量
        self.total_net_process(dst,src,pack_size)

    def total_net_process(self,dst,src,pack_size):
        '''
            @name 统计进程流量
            @author hwliang<2021-09-13>
            @param dst<bytes> 目标地址
            @param src<bytes> 源地址
            @param pack_size<int> 数据包长度
            @return void
        '''
        self.get_tcp_stat()
        direction = None
        mtime = time.time()
        if dst in self.__net_process_list:
            pid = self.__net_process_list[dst]
            direction = 'down'
        elif src in self.__net_process_list:
            pid = self.__net_process_list[src]
            direction = 'up'
        else:
            if mtime - self.__last_stat > 3:
                self.__last_stat = mtime
                self.get_tcp_stat(True)
                if dst in self.__net_process_list:
                    pid = self.__net_process_list[dst]
                    direction = 'down'
                elif src in self.__net_process_list:
                    pid = self.__net_process_list[src]
                    direction = 'up'

        if not direction: return False
        if not pid: return False
        if not pid in self.__net_process_size:
            self.__net_process_size[pid] = {}
            self.__net_process_size[pid]['down'] = 0
            self.__net_process_size[pid]['up'] = 0
            self.__net_process_size[pid]['up_package'] = 0
            self.__net_process_size[pid]['down_package'] = 0

        self.__net_process_size[pid][direction] += pack_size
        self.__net_process_size[pid][direction + '_package'] += 1

        # 写入到文件
        if mtime - self.__last_write_time > 1:
            self.__last_write_time = mtime
            self.write_net_process()

    def write_net_process(self):
        '''
            @name 写入进程流量
            @author hwliang<2021-09-13>
            @return void
        '''
        w_file = '/dev/shm/bt_net_process'
        process_size = copy.deepcopy(self.__net_process_size)
        net_process = []
        for pid in process_size.keys():
            net_process.append(str(pid) + " " + str(process_size[pid]['down']) + " " + str(process_size[pid]['up']) + " " + str(process_size[pid]['down_package']) + " " + str(process_size[pid]['up_package']))

        f = open(w_file,'w+',encoding='utf-8')
        f.write('\n'.join(net_process))
        f.close()

    def hex_to_ip(self, hex_ip):
        '''
            @name 将16进制的IP地址转换为字符串IP地址
            @author hwliang<2021-09-13>
            @param hex_ip<string> 16进制的IP地址:16进程端口
            @return tuple(ip<str>,port<int>) IP地址,端口
        '''
        hex_ip,hex_port = hex_ip.split(':')
        ip = '.'.join([str(int(hex_ip[i:i+2], 16)) for i in range(0, len(hex_ip), 2)][::-1])
        port = int(hex_port, 16)
        return ip,port

    def get_tcp_stat(self,force = False):
        '''
            @name 获取当前TCP连接状态表
            @author hwliang<2021-09-13>
            @param force<bool> 是否强制刷新
            @return dict
        '''
        if not force and self.__net_process_list: return self.__net_process_list
        self.__net_process_list = {}
        tcp_stat_file = '/proc/net/tcp'
        tcp_stat = open(tcp_stat_file, 'rb')
        tcp_stat_list = tcp_stat.read().decode('utf-8').split('\n')
        tcp_stat.close()
        tcp_stat_list = tcp_stat_list[1:]
        if force: self.get_process_inodes(force)
        for i in tcp_stat_list:
            tcp_tmp = i.split()
            if len(tcp_tmp) < 10: continue
            inode = tcp_tmp[9]
            if inode == '0': continue
            local_ip,local_port = self.hex_to_ip(tcp_tmp[1])
            if local_ip == '127.0.0.1': continue
            remote_ip,remote_port = self.hex_to_ip(tcp_tmp[2])
            if local_ip == remote_ip: continue
            if remote_ip == '0.0.0.0': continue

            pid = self.inode_to_pid(inode,force)
            if not pid: continue

            key = self.get_ip_pack(local_ip) + b':' + self.get_port_pack(local_port)
            self.__net_process_list[key] = pid
        return self.__net_process_list


    def get_port_pack(self,port):
        '''
            @name 将端口转换为字节流
            @author hwliang<2021-09-13>
            @param port<int> 端口
            @return bytes
        '''
        return struct.pack('H',int(port))[::-1]

    def get_ip_pack(self,ip):
        '''
            @name 将IP地址转换为字节流
            @author hwliang<2021-09-13>
            @param ip<str> IP地址
            @return bytes
        '''
        ip_arr = ip.split('.')
        ip_pack = b''
        for i in ip_arr:
            ip_pack += struct.pack('B',int(i))
        return ip_pack

    def inode_to_pid(self,inode,force = False):
        '''
            @name 将inode转换为进程ID
            @author hwliang<2021-09-13>
            @param inode<string> inode
            @param force<bool> 是否强制刷新
            @return int
        '''
        inode_list = self.get_process_inodes()
        if inode in inode_list:
            return inode_list[inode]
        return None

    def get_process_inodes(self,force = False):
        '''
            @name 获取进程inode列表
            @author hwliang<2021-09-13>
            @param force<bool> 是否强制刷新
            @return dict
        '''
        if not force and self.__inode_list: return self.__inode_list
        proc_path = '/proc'
        inode_list = {}
        for pid in os.listdir(proc_path):
            try:
                if not pid.isdigit(): continue
                inode_path = proc_path + '/' + pid + '/fd'
                for fd in os.listdir(inode_path):
                    try:
                        fd_file = inode_path + '/' + fd
                        fd_link = os.readlink(fd_file)
                        if fd_link.startswith('socket:['):
                            inode = fd_link[8:-1]
                            inode_list[inode] = pid
                    except:
                        continue
            except:
                continue
        self.__inode_list = inode_list
        return inode_list

    def get_process_name(self,pid):
        '''
            @name 获取进程名称
            @author hwliang<2021-09-13>
            @param pid<str> 进程ID
            @return str
        '''
        pid_path = '/proc/' + pid + '/comm'
        if not os.path.exists(pid_path): return ''
        pid_file = open(pid_path, 'rb')
        pid_name = pid_file.read().decode('utf-8').strip()
        pid_file.close()
        return pid_name


    def write_pid(self):
        '''
            @name 写入进程ID到PID文件
            @author hwliang<2021-09-13>
            @return void
        '''
        self_pid = os.getpid()
        pid_file = open(self.__pid_file,'w')
        pid_file.write(str(self_pid))
        pid_file.close()

    def rm_pid_file(self):
        '''
            @name 删除进程pid文件
            @author hwliang<2021-09-13>
            @return void
        '''
        if os.path.exists(self.__pid_file):
            os.remove(self.__pid_file)


class process_task:
    __pids = []
    __last_times = {}
    __last_dates = {}
    __write_last = {}
    __write_dates = {}
    __read_last = {}
    __read_dates = {}
    __cpu_count = cpu_count()
    __cache = SimpleCache(5000)
    last_net_process = {}
    last_net_process_time = 0
    __process_net_list = {}
    __process_object = {}
    __insert_time = 0
    __last_cpu_time = 0
    old_key = 'old_cpu_times'
    new_key = 'new_cpu_times'
    new_info = {}
    old_info = {}


    def __init__(self):

        tip_file = '{}/data/process_index.pl'.format(public.get_panel_path())
        if not public.M('sqlite_master').dbfile('system').where(
                'type=? AND name=?', ('table', 'process_top_list')).count():
            public.ExecShell('rm -f {}'.format(tip_file))
        if not os.path.isfile(tip_file):
            _sql = db.Sql().dbfile('system')
            csql = '''CREATE TABLE IF NOT EXISTS `process_top_list` (
  `id` INTEGER PRIMARY KEY AUTOINCREMENT,
  `cpu_top` REAL,
  `memory_top` REAL,
  `swap_top` REAL,
  `disk_top` REAL,
  `net_top` REAL,
  `all_top` REAL,
  `addtime` INTEGER
)'''
            _sql.execute(csql, ())
            _sql.execute('CREATE INDEX `addtime` ON `process_top_list` (`addtime`)', ())
            _sql.close()
            public.writeFile(tip_file,'True')

    def get_pids(self):
        '''
            @name 获取pid列表
            @author hwliang<2021-09-04>
            @return None
        '''
        self.__pids = pids()

    def get_cpu_time(self):
        s = cpu_times()
        return s.user + s.system + s.nice + s.idle

    def get_old(self):
        if self.old_info: return True
        data = self.__cache.get(self.old_key)
        if not data: return False
        if not data: return False
        self.old_info = data
        del(data)
        return True


    # def get_cpu_percent(self,pid,cpu_times,cpu_time):
    #     self.get_old()
    #     percent = 0.00
    #     process_cpu_time = self.get_process_cpu_time(cpu_times)
    #     if not self.old_info: self.old_info = {}
    #     if not pid in self.old_info:
    #         self.new_info[pid] = {}
    #         self.new_info[pid]['cpu_time'] = process_cpu_time
    #         return percent
    #     percent = round(100.00 * (process_cpu_time - self.old_info[pid]['cpu_time']) / (cpu_time - self.old_info['cpu_time']),2)
    #     self.new_info[pid] = {}
    #     self.new_info[pid]['cpu_time'] = process_cpu_time
    #     if percent > 0: return percent
    #     return 0.00

    def get_process_cpu_time(self,cpu_times):
        cpu_time = 0.00
        for s in cpu_times: cpu_time += s
        return cpu_time

    def get_cpu_percent(self,pid,cpu_time_total,s_cpu_times):
        '''
            @name 获取pid的cpu占用率
            @author hwliang<2021-09-04>
            @param pid 进程id
            @param cpu_time_total 进程总cpu时间
            @return 占用cpu百分比
        '''
        stime = time.time()
        if pid in self.__last_times:
            old_time = self.__last_times[pid]
        else:
            self.__last_times[pid] = cpu_time_total
            self.__last_dates[pid] = stime
            return 0

        cpu_percent = round(100.00 * float(cpu_time_total - old_time) / (s_cpu_times - self.__last_cpu_time),2)
        self.__last_times[pid] = cpu_time_total
        self.__last_dates[pid] = stime
        if cpu_percent > 100: cpu_percent = 99
        if cpu_percent < 0: cpu_percent = 0
        return cpu_percent


    def get_io_write(self,pid,io_write):
        disk_io_write = 0
        stime = time.time()
        if pid in self.__write_last:
            old_write = self.__write_last[pid]
        else:
            self.__write_last[pid] = io_write
            self.__write_dates[pid] = stime
            return disk_io_write

        io_end = (io_write - old_write)
        if io_end > 0:
            disk_io_write = int(io_end / (stime - self.__write_dates[pid]))

        self.__write_last[pid] = io_write
        self.__write_dates[pid] = stime
        if disk_io_write < 0: disk_io_write = 0
        return disk_io_write


    def get_io_read(self,pid,io_read):
        disk_io_read = 0
        stime = time.time()
        if pid in self.__read_last:
            old_read = self.__read_last[pid]
        else:
            self.__read_last[pid] = io_read
            self.__read_dates[pid] = stime
            return disk_io_read

        io_end = (io_read - old_read)
        if io_end > 0:
            disk_io_read = int(io_end / (stime - self.__read_dates[pid]))

        self.__read_last[pid] = io_read
        self.__read_dates[pid] = stime
        if disk_io_read < 0: disk_io_read = 0
        return disk_io_read

    def read_file(self,filename):
        f = open(filename,'rb')
        result = f.read()
        f.close()
        return result.decode().replace("\u0000"," ").strip()




    def get_process_net_list(self):
        w_file = '/dev/shm/bt_net_process'
        if not os.path.exists(w_file): return
        self.last_net_process = self.__cache.get('net_process')
        self.last_net_process_time = self.__cache.get('last_net_process')
        net_process_body  = self.read_file(w_file)
        if not net_process_body: return
        net_process = net_process_body.split('\n')
        for np in net_process:
            if not np: continue
            tmp = {}
            np_list = np.split()
            if len(np_list) < 5: continue
            tmp['pid'] = int(np_list[0])
            tmp['down'] = int(np_list[1])
            tmp['up'] = int(np_list[2])
            tmp['down_package'] = int(np_list[3])
            tmp['up_package'] = int(np_list[4])
            self.__process_net_list[str(tmp['pid'])] = tmp
        self.__cache.set('net_process',self.__process_net_list,600)
        self.__cache.set('last_net_process',time.time(),600)

    def get_process_network(self,pid):
        '''
            @name 获取进程网络流量
            @author hwliang<2021-09-13>
            @param pid<int> 进程ID
            @return tuple
        '''

        if not self.__process_net_list:
            self.get_process_net_list()
        if not self.last_net_process_time:
            return 0,0,0,0
        if not pid in self.__process_net_list.keys():
            return 0,0,0,0

        if not pid in self.last_net_process:
            return self.__process_net_list[pid]['up'],self.__process_net_list[pid]['up_package'],self.__process_net_list[pid]['down'],self.__process_net_list[pid]['down_package']

        up = int((self.__process_net_list[pid]['up'] - self.last_net_process[pid]['up']) / (time.time() - self.last_net_process_time))
        down = int((self.__process_net_list[pid]['down'] - self.last_net_process[pid]['down']) / (time.time() - self.last_net_process_time))
        up_package = int((self.__process_net_list[pid]['up_package'] - self.last_net_process[pid]['up_package']) / (time.time() - self.last_net_process_time))
        down_package = int((self.__process_net_list[pid]['down_package'] - self.last_net_process[pid]['down_package']) / (time.time() - self.last_net_process_time))
        if up < 0: up = 0
        if down < 0: down = 0
        if up_package < 0: up_package = 0
        if down_package < 0: down_package = 0
        return up,up_package,down,down_package


    def get_process_username(self,pid):
        '''
            @name 获取进程用户名
            @param pid 进程id
            @return 用户名
        '''
        try:
            import pwd
            return pwd.getpwuid(os.stat('/proc/' + str(pid)).st_uid).pw_name
        except:
            return 'root'


    def get_monitor_list(self,stime = None):
        '''
            @name 获取监控列表
            @author hwliang<2021-09-04>
            @return list
        '''
        self.get_pids()
        process_info_list = []
        total_cpu_precent = 0.0
        my_pid = os.getpid()
        if type(self.new_info) != dict: self.new_info = {}
        all_cpu_time = self.get_cpu_time()
        self.new_info['time'] = time.time()

        for pid in self.__pids:
            try:
                # if pid < 100: continue
                if pid == my_pid: continue
                if not pid in self.__process_object.keys():
                    self.__process_object[pid] = Process(pid)
                try:
                    if self.__process_object[pid].status() == 'terminated':
                        self.__process_object[pid] = Process(pid).create_time
                except:
                    self.__process_object[pid] = Process(pid)
                p = self.__process_object[pid]

                process_info = {}
                process_info['cpu_percent'] = self.get_cpu_percent(str(pid),sum(p.cpu_times()),all_cpu_time) #self.get_cpu_percent(pid,int(sum(p.cpu_times())),self.new_info['cpu_time'])         # CPU使用率
                total_cpu_precent += process_info['cpu_percent']
                process_info['memory'] = p.memory_info().rss                                            # 内存占用
                if not process_info['memory']: continue
                # ========== 新增：获取Swap占用 ==========

                try:
                    # swap_used_cmd = f"awk '/VmSwap/{{print $2}}' /proc/{pid}/status"
                    # process_info['swap']=int(public.ExecShell(swap_used_cmd)[0].strip())
                    process_info['swap']=p.memory_full_info().swap
                except:
                    process_info['swap']=0

                io_counters = p.io_counters()
                process_info['disk_read'] = self.get_io_read(pid,io_counters.read_bytes)                # 读取磁盘字节数
                process_info['disk_write'] = self.get_io_write(pid,io_counters.write_bytes)             # 写入磁盘字节数
                process_info['disk_total'] = process_info['disk_read'] + process_info['disk_write']     # 磁盘总读写

                process_info['up'],process_info['up_package'],process_info['down'],process_info['down_package'] = self.get_process_network(str(pid))

                process_info['net_total'] = process_info['up'] + process_info['down']                   # 网络总流量
                process_info['package_total'] = process_info['up_package'] + process_info['down_package'] # 网络总包数

                if not process_info['cpu_percent'] and not process_info['disk_total'] and not process_info['net_total']: continue
                process_proc_comm = '/proc/{}/comm'.format(pid)
                process_proc_cmdline = '/proc/{}/cmdline'.format(pid)
                process_info['pid'] = pid
                process_info['name'] = self.read_file(process_proc_comm)
                process_info['cmdline'] = self.read_file(process_proc_cmdline)                                           # 启动命令
                process_info['create_time'] = int(p.create_time())                                                          # 创建时间
                process_info['connect_count'] = len(p.connections())                                                      # 连接数
                process_info['username'] = self.get_process_username(pid)                                                 # 进程用户名
                process_info_list.append(process_info)
            except:
                continue

        self.__last_cpu_time = all_cpu_time
        self.__process_net_list.clear()
        self.insert_db(process_info_list,stime)
        # import public
        # for pp in sorted(process_info_list,key=lambda x:x['cpu_percent'],reverse=True):
        #     public.print_log("name: {}, cpu_percent: {}".format(pp['name'], pp['cpu_percent']))
        if total_cpu_precent > 100: total_cpu_precent = 100
        return total_cpu_precent

    def get_expire_time(self):
        '''
            @name 获取过期时间
            @return int
        '''
        filename = 'data/control.conf'
        _day = 30
        if os.path.exists(filename):
            try:
                conf = self.read_file(filename)
                if conf: _day = int(conf)
            except: pass
        return _day * 86400



    def insert_db(self,process_info_list,_time):
        '''
            @name 插入数据库
            @param process_info_list list
            @return bool
        '''
        if not process_info_list: return
        all_top,cpu_top,disk_top,net_top,memory_top,swap_top = self.get_top_list(process_info_list)

        with db.Sql().dbfile('system') as _sql:
            #检测process_top_list表是否存在swap_top字段
            field = 'cpu_top,swap_top'
            check_result=_sql.table('process_top_list').order("id desc").field(field).select()
            if type(check_result) == str:
                _sql.table('process_top_list').execute("ALTER TABLE 'process_top_list' ADD 'swap_top' REAL DEFAULT []",())
            if not _time:
                _time = int(time.time())
            _sql.table('process_top_list').insert({
                'all_top':dumps(all_top),
                'cpu_top':dumps(cpu_top),
                'disk_top':dumps(disk_top),
                'net_top':dumps(net_top),
                'memory_top':dumps(memory_top),
                'swap_top':dumps(swap_top),
                'addtime':_time
            })

            # 删除过期数据
            if self.__insert_time and _time - self.__insert_time > 3600:
                self.__insert_time = _time
                _sql.table('process_top_list').where('addtime<?',self.get_expire_time()).delete()
            _sql.close()



    def get_top_list(sekf,process_info_list):
        '''
            @name 排序
            @param process_info_list list
            @return list
        '''
        process_info_list = sorted(process_info_list,key=lambda x:[x['cpu_percent'],x['disk_total'],x['net_total'],x['memory']],reverse=True)
        top_num = 5
        all_top = []
        for p in process_info_list[:top_num]:
            _line = [p['cpu_percent'],p['disk_read'],p['disk_write'],p['memory'],p['up'],p['down'],p['pid'],public.xssencode2(p['name']),public.xssencode2(p['cmdline']),public.xssencode2(p['username']),p['create_time']]
            all_top.append(_line)


        process_info_list = sorted(process_info_list,key=lambda x:x['cpu_percent'],reverse=True)
        cpu_top = []
        for p in process_info_list[:top_num]:
            if not p['cpu_percent']: continue
            _line = [p['cpu_percent'],p['pid'],public.xssencode2(p['name']),public.xssencode2(p['cmdline']),public.xssencode2(p['username']),p['create_time']]
            cpu_top.append(_line)

        process_info_list = sorted(process_info_list,key=lambda x:x['disk_total'],reverse=True)
        disk_top = []
        for p in process_info_list[:top_num]:
            if not p['disk_total']: continue
            _line = [p['disk_total'],p['disk_read'],p['disk_write'],p['pid'],public.xssencode2(p['name']),public.xssencode2(p['cmdline']),public.xssencode2(p['username']),p['create_time']]
            disk_top.append(_line)

        process_info_list = sorted(process_info_list,key=lambda x:x['net_total'],reverse=True)
        net_top = []
        for p in process_info_list[:top_num]:
            if not p['net_total']: continue
            _line = [p['net_total'],p['up'],p['down'],p['connect_count'],p['package_total'],p['pid'],public.xssencode2(p['name']),public.xssencode2(p['cmdline']),public.xssencode2(p['username']),p['create_time']]
            net_top.append(_line)

        process_info_list = sorted(process_info_list,key=lambda x:x['memory'],reverse=True)
        memory_top = []
        for p in process_info_list[:top_num]:
            if not p['memory']: continue
            _line = [p['memory'],p['pid'],public.xssencode2(p['name']),public.xssencode2(p['cmdline']),public.xssencode2(p['username']),p['create_time']]
            memory_top.append(_line)
 
        process_info_list = sorted(process_info_list,key=lambda x:x['swap'],reverse=True)
        swap_top = []
        for p in process_info_list[:top_num]:
            if not p['swap']: continue
            _line = [p['swap'],p['pid'],public.xssencode2(p['name']),public.xssencode2(p['cmdline']),public.xssencode2(p['username']),p['create_time']]
            swap_top.append(_line)

        return all_top,cpu_top,disk_top,net_top,memory_top,swap_top




if __name__ == '__main__':
    # net = process_network_total()
    # threading.Thread(target = net.start,args=()).start()

    p = process_task()
    while True:
        p.get_monitor_list()
        time.sleep(1)
        print("-"*50)